commit 434d6067d9c0f11f7473fc853c170d88e80e2590 Author: Mario Fetka Date: Tue Sep 22 02:25:22 2020 +0200 Imported Upstream version 1.5.1 diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..3ad3654 --- /dev/null +++ b/AUTHORS @@ -0,0 +1,20 @@ +Michael Berlin +Eugenio Cesario +Johannes Dillmann +Jan Fajerski +Jens V. Fischer +Juan Gonzalez +Lukas Kairies +Christoph Kleineweber +Björn Kolbeck +Nico Kruber +Felix Langner +Philippe Lieser +Christian Lorenz +Matthias Noack +Patrick Schäfer +Robert Schmidtke +Thorsten Schuett +Paul Seiferth +Dmitry Smirnov +Jan Stender diff --git a/CHANGELOG b/CHANGELOG new file mode 100644 index 0000000..27486c5 --- /dev/null +++ b/CHANGELOG @@ -0,0 +1,92 @@ +12-MAR-2015: release 1.5.1 + + Changes: + * Hadoop Adapter supports Hadoop-2.x and other applications running on the YARN platform (tested with Apache Spark and Apache Flink), new OSD selection policy that imitates the HDFS placement behavior. + * Consistent adding and removing replicas for R/W replication. + * xtfs_scrup now replaces failed replicas using the R/W replication policy. + * Improvements of the SSL mode: the used SSL/TLS version is selectable, strict certificate chain checks are possible, the SSL code on client and server side was improved. + * Support for PKCS12 certificate containers is remove from the Windows client (did not work in previous release). + * mount.xtreemfs accepts all parameters to be passed in the form -o option=value. If XtreemFS is mounted via /etc/fstab, mount options are passed to the XtreemFS client. + * Dockerfiles for the XtreemFS services are available at https://github.com/xtreemfs/xtreemfs-docker. + * A Vagrantfile is available in the XtreemFS repository to ease development and testing for new contributors. + * Fixed snapshots in the case of deleted files. + * Snapshots can be deleted even after inactivating snapshots for a volume (issue 290). + * Initial version of an LD_PRELOAD based client that bypasses FUSE (experimental). + * Initial implementation of volume quotas (checked only while opening files by the MRC). + * OSDs can report their health to the DIR (e.g. based on SMART values), which aggregates this information in the web interface. A new OSD selection policy sorts out unhealthy OSDs. + * Improved automatic testing: introduced Travis-CI, migrated all JUnit tests to version 4, improved reliability of nightly integration tests. + * Added new benchmark tool xtfs_benchmark that is based on the JAVA libxtreemfs. + * Many small improvements and fixes. + +12-MAR-2014: release 1.5 (Wonderful Waffles) + + Changes: + * Improved Hadoop Adapter e.g., added support for multiple volumes and read and write buffer to speed up performance. + * Support for SSDs: Support for multiple OSD storage threads to increase parallelism. + * Status webpage as part of the DIR webinterface for replicated files to show current primary and backup replicas. + * Multi-homing support. XtreemFS can now be made available for multiple networks and clients will pick the correct address automatically. + * Support for multiple OSDs per machine (e.g. one for each disk) through the xtreemfs-osd-farm init.d script. + * Fixed major issues in Read-Only and Read/Write file replication. + * Reduced metadata cache default timeout from 120 to 10 seconds. Disable it completely with --metadata-cache-size=0. + * Upgraded to Google Protobuffers 2.5 which improves performance. + * Windows Client: Fixed several issues (e.g., 286, 299) and updated the CbFS driver to the latest version. + * XtreemFS also compiles under buildroot now. + * Fixed several issues around SSL (e.g., 263, 281). + * Fixed many small issues e.g., reported volume capacity was inaccurate (issue 296). + Other fixed issues: 267, 268, 272, 274, 276, 277, 278, 283, 287, 288, 292, 293, 294. + * Improved general stability (e.g., see issues 297, 301). + * xtfs_scrub now repairs replicas with an invalid checksum automatically. + * Disabled deferred deletion of file data on the OSDs. + * Improved test coverage of nightly tests and added missing unit tests and a Valgrind leak check for C++ unit tests. + +12-NOV-2012: release 1.4 (Salty Sticks) + + Changes: + * Improved stability: Fixed client crashes when timeouts occurred; fixed server crashes and issues with the R/W replication. + * Full support for asynchronous writes: If a client is started with "--enable-async-writes", write() requests will be immediately acknowledged by the client and executed in the background. Outstanding writes are always flushed at close() or fsync*() events. This improves the write throughput, especially in case of connections with high latency. + * Added Windows Client Beta which uses Eldos' Callback File System product instead of Dokan. + * Re-wrote HDFS interface implementation: Use XtreemFS as replacement for HDFS in your Hadoop setup. + * libxtreemfs for Java: Access XtreemFS directly from your Java application. See source files org.xtreemfs.common.libxtreemfs.{Client,Volume,FileHandle}.java for the interface. + * Re-added Vivaldi support and added/improved its functionality: + * Vivaldi is directly integrated in the client now and can be enabled with '--vivaldi-enable'. + * Added Vivaldi visualization: see '/vivaldi' subpage on DIR. Have a look at our demo server to get an impressium: http://demo.xtreemfs.org:30638/vivaldi + * Coordinates of clients can be also visualized if clients reporting was enabled with '--vivaldi-enable-dir-updates'. + * Added support for OSD Selection based on Custom Attributes. For example, assign a country code to every OSD as custom attribute and limit the placement of files on OSDs based on the attribute. + + * Rewrote xtfs_scrub tool and fixed support for read-only replicated files and checksums. R/W replicas will be supported in the next release. + * Certificate password provided on command line no longer visible in process listing output. Additionally, the password can be entered on stdin now. (Issue 251) + * Support for binary extended attributes (allows to preserve POSIX ACLs when copying data to XtreemFS; however they are not evaluated - use the XtreemFS ACLs therefore). + * Fixed several client issues (e.g., 231, 234, 237). + * Fixed clock synchronization problems which impaired the DIR/MRC replication. This also fixed issue 236. + * Client: Added DIR fail over support. Specify multiple DIR replicas when mounting as follows: mount.xtreemfs dir1,dir2,dir3/volume. However, please note that the DIR/MRC replication is still experimental and not officially supported yet. + * MacOSX Client: Fixed wrong df output (issue 247). Fixed failed installer if XtreemFS is already installed (issue 239). Fixed installer check if FUSE is installed (also works for OSXFUSE now) (issue 197). + * Volume Snapshots Tools: Functionality was moved from "xtfs_snap" tool to "xtfsutil". + * Various minor fixes. + + * MRC: To prevent confusion, global policy attributes are no longer allowed and always have to be prefixed by the policy id e.g., "1002.uuids". + * init.d scripts no longer store a lock file in /var/lock/subsys. You can remove this directory now. + +03-NOV-2011: release 1.3.1 + * Added 'xtfs_remove_osd' utility to remove OSDs from an XtreemFS installation. All files on the OSD to be removed will be relocated to different OSDs. + * Added first support for asynchronous writes in the client. Mounting with '--max-writeahead' and '--max-writeahead-requests' allows the user to specify the maximum number of bytes and requests to be sent to an OSD before receiving an acknowledgment. However, this feature currently does not work together with replication and retries. + * Added monitoring support to servers. Various characteristics are accessible now via SNMP, such as data transfer statistics, memory usage, numbers of files and directories, etc. A Ganglia plugin makes it possible to visualize them. + * improved stability of MRC/DIR replication + * improved the behavior of the read-write replication under heavy load by internally limiting the length of request queues + * made several usability changes to xtfsutil + * added '/babudb' subpage to MRC/DIR status page that shows internal database statistics + * added Gentoo overlay + * installing XtreemFS now creates symlinks '/sbin/mount.xtreemfs' and '/sbin/umount.xtreemfs' in order to support XtreemFS mounting via fstab (however, not all client options are available in the fstab yet, see issue 205) + * the replication policy "WaRa" was renamed to "WaR1" + * fixed issues 196, 198-204, 206-209, 211-218, 220, 222 + * fixed a wide range of issues w/ read-only and read-write replication of files + * fixed issues w/ several MRC calls when admin passwords were specified (a consequence of this is that an XtreemFS 1.3.0 client can no longer mount admin_password protected MRCs; upgrade the client to 1.3.1 to fix this) + * fixed various client issues, such as deadlocks and memory leaks + +10-AUG-2011: release 1.3.0 (Tasty Tartlet) + * added new features: full read-write replication of files, snapshots + * completely re-wrote the client + - it now supports metadata caching and automatic fail-over for replicated files + - a client library 'libxtreemfs' separates the client logic from platform-specific bindings (e.g. FUSE, Dokan) + * added first prototypes of metadata (MRC and DIR) replication + * merged all user tools into a new general-purpose tool 'xtfsutil' + * changed license from GPL to BSD diff --git a/KNOWN_ISSUES b/KNOWN_ISSUES new file mode 100644 index 0000000..28b1b5f --- /dev/null +++ b/KNOWN_ISSUES @@ -0,0 +1,8 @@ +From release 1.3.1 on, we document all known limitations of XtreemFS +in our issue tracker and mark each with the label "KnownLimitations". + +Please have a look at + + https://github.com/xtreemfs/xtreemfs/labels/KnownLimitations + +for the complete list of current known limitations. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..c5ef559 --- /dev/null +++ b/LICENSE @@ -0,0 +1,35 @@ +Copyright (c) 2008-2012, Michael Berlin, Eugenio Cesario, +Juan Gonzalez, Björn Kolbeck, Felix Langner, Christian Lorenz, +Matthias Noack, Patrick Schäfer, Paul Seiferth, Jan Stender + + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + * Neither the name of the Zuse Institute Berlin nor the + names of its contributors may be used to endorse or promote + products derived from this software without specific prior + written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..16de650 --- /dev/null +++ b/Makefile @@ -0,0 +1,349 @@ +ifeq "$(JAVA_HOME)" "" + JAVAC_BIN = /usr/bin/javac +else + JAVAC_BIN = $(JAVA_HOME)/bin/javac +endif + +ifeq "$(ANT_HOME)" "" + ANT_BIN = /usr/bin/ant +else + ANT_BIN = $(ANT_HOME)/bin/ant +endif + +ifeq "$(CMAKE_HOME)" "" + CMAKE_BIN = cmake +else + CMAKE_BIN = $(CMAKE_HOME)/bin/cmake +endif + +SHELL := $(shell which bash) +WHICH_GPP = $(shell which g++) +WHICH_CLANGPP = $(shell which clang++) + +ifeq "$(shell uname)" "SunOS" + PROTOBUF_DISABLE_64_BIT_SOLARIS = "--disable-64bit-solaris" +endif + +# Paths used during compilation. +XTREEMFS_CLIENT_BUILD_DIR=$(shell pwd)/cpp/build +XTREEMFS_BINARIES_DIR = $(shell pwd)/bin + +# Install paths relative to DESTDIR. +XTREEMFS_JAR_DIR=$(DESTDIR)/usr/share/java +XTREEMFS_CONFIG_PARENT_DIR=$(DESTDIR)/etc/xos +XTREEMFS_CONFIG_DIR=$(XTREEMFS_CONFIG_PARENT_DIR)/xtreemfs +XTREEMFS_INIT_DIR=$(DESTDIR)/etc/init.d +XTREEMFS_SHARE_DIR=$(DESTDIR)/usr/share/xtreemfs +BIN_DIR=$(DESTDIR)/usr/bin +SBIN_DIR=$(DESTDIR)/sbin +MAN_DIR=$(DESTDIR)/usr/share/man/man1 +DOC_DIR_SERVER=$(DESTDIR)/usr/share/doc/xtreemfs-server +DOC_DIR_CLIENT=$(DESTDIR)/usr/share/doc/xtreemfs-client +DOC_DIR_TOOLS=$(DESTDIR)/usr/share/doc/xtreemfs-tools +PLUGIN_CONFIG_DIR=$(XTREEMFS_CONFIG_DIR)/server-repl-plugin + +#Configuration of cpp code thirdparty dependencies. +# If you edit the next five variables, make sure you also change them in cpp/CMakeLists.txt. +CLIENT_GOOGLE_PROTOBUF_CPP = cpp/thirdparty/protobuf-2.5.0 +CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY = $(CLIENT_GOOGLE_PROTOBUF_CPP)/src/.libs/libprotobuf.a +CLIENT_GOOGLE_TEST_CPP = cpp/thirdparty/gtest-1.7.0 +CLIENT_GOOGLE_TEST_CPP_LIBRARY = $(CLIENT_GOOGLE_TEST_CPP)/lib/.libs/libgtest.a +CLIENT_GOOGLE_TEST_CPP_MAIN = $(CLIENT_GOOGLE_TEST_CPP)/lib/.libs/libgtest_main.a +# The two required objects libgtest.a and libgtest_main.a both depend +# on the same target building the Google googletest library. +# Therefore, this target is guarded by a checkfile which will be touched once it was executed. +# This prevents the target from getting executed again as long as the checkfile does not change. +CLIENT_GOOGLE_TEST_CHECKFILE = .googletest_library_already_built + +TARGETS = client server foundation flease +.PHONY: clean distclean set_version + +all: check_server check_client check_test $(TARGETS) + +clean: check_server check_client $(patsubst %,%_clean,$(TARGETS)) + +distclean: check_server check_client $(patsubst %,%_distclean,$(TARGETS)) + +install: install-client install-server install-tools + +install-client: + + @if [ ! -f $(XTREEMFS_BINARIES_DIR)/mkfs.xtreemfs ]; then echo "PLEASE RUN 'make client' FIRST!"; exit 1; fi + + @mkdir -p $(DOC_DIR_CLIENT) + @cp LICENSE $(DOC_DIR_CLIENT) + + @mkdir -p $(BIN_DIR) + @cp -p $(XTREEMFS_BINARIES_DIR)/*.xtreemfs $(XTREEMFS_BINARIES_DIR)/xtfsutil $(BIN_DIR) + +# mount -t xtreemfs will be recognized when binaries are present in /sbin/. Only applicable if the Fuse Client was built. + @[ -f $(XTREEMFS_BINARIES_DIR)/mount.xtreemfs ] && mkdir -p $(SBIN_DIR); true + @[ -f $(XTREEMFS_BINARIES_DIR)/mount.xtreemfs ] && ln -s $(BIN_DIR)/mount.xtreemfs $(SBIN_DIR)/mount.xtreemfs; true + @[ -f $(XTREEMFS_BINARIES_DIR)/mount.xtreemfs ] && ln -s $(BIN_DIR)/umount.xtreemfs $(SBIN_DIR)/umount.xtreemfs; true + + @mkdir -p $(XTREEMFS_CONFIG_DIR) + @cp etc/xos/xtreemfs/default_dir $(XTREEMFS_CONFIG_DIR) + + @mkdir -p $(MAN_DIR) + @cp -R man/man1/*.xtreemfs* $(MAN_DIR) + @cp -R man/man1/xtfsutil.* $(MAN_DIR) + +install-server: + + @if [ ! -f java/servers/dist/XtreemFS.jar ]; then echo "PLEASE RUN 'make server' FIRST!"; exit 1; fi + + @mkdir -p $(DOC_DIR_SERVER) + @cp LICENSE $(DOC_DIR_SERVER) + + @mkdir -p $(XTREEMFS_JAR_DIR) + @cp java/servers/dist/XtreemFS.jar $(XTREEMFS_JAR_DIR) + @cp java/foundation/dist/Foundation.jar $(XTREEMFS_JAR_DIR) + @cp java/flease/dist/Flease.jar $(XTREEMFS_JAR_DIR) + @cp java/lib/*.jar $(XTREEMFS_JAR_DIR) + @cp contrib/server-repl-plugin/BabuDB_replication_plugin.jar $(XTREEMFS_JAR_DIR) + + @mkdir -p $(XTREEMFS_CONFIG_DIR) +# @cp etc/xos/xtreemfs/*config.properties $(XTREEMFS_CONFIG_DIR) +# delete UUID from config-files + @grep -v '^uuid\W*=\W*\w\+' etc/xos/xtreemfs/dirconfig.properties > $(XTREEMFS_CONFIG_DIR)/dirconfig.properties + @grep -v '^uuid\W*=\W*\w\+' etc/xos/xtreemfs/mrcconfig.properties > $(XTREEMFS_CONFIG_DIR)/mrcconfig.properties + @grep -v '^uuid\W*=\W*\w\+' etc/xos/xtreemfs/osdconfig.properties > $(XTREEMFS_CONFIG_DIR)/osdconfig.properties + + @mkdir -p $(PLUGIN_CONFIG_DIR) + @cp contrib/server-repl-plugin/config/dir.properties $(PLUGIN_CONFIG_DIR) + @cp contrib/server-repl-plugin/config/mrc.properties $(PLUGIN_CONFIG_DIR) + + @cp packaging/generate_uuid $(XTREEMFS_CONFIG_DIR) + @cp packaging/postinstall_setup.sh $(XTREEMFS_CONFIG_DIR) + @chmod a+x $(XTREEMFS_CONFIG_DIR)/postinstall_setup.sh + +# Generating init.d scripts based on template. + @etc/init.d/generate_initd_scripts.sh + @mkdir -p $(XTREEMFS_INIT_DIR) + @cp etc/init.d/xtreemfs-{dir,mrc,osd} $(XTREEMFS_INIT_DIR) + @chmod a+x $(XTREEMFS_INIT_DIR)/xtreemfs-* + + @mkdir -p $(XTREEMFS_SHARE_DIR) + @cp contrib/xtreemfs-osd-farm/xtreemfs-osd-farm $(XTREEMFS_SHARE_DIR) + + @echo "to complete the server installation, please execute $(XTREEMFS_CONFIG_DIR)/postinstall_setup.sh" + +install-tools: + + @if [ ! -f java/servers/dist/XtreemFS.jar ]; then echo "PLEASE RUN 'make server' FIRST!"; exit 1; fi + + @mkdir -p $(DOC_DIR_TOOLS) + @cp LICENSE $(DOC_DIR_TOOLS) + + @mkdir -p $(XTREEMFS_JAR_DIR) + @cp java/servers/dist/XtreemFS.jar $(XTREEMFS_JAR_DIR) + @cp java/foundation/dist/Foundation.jar $(XTREEMFS_JAR_DIR) + @cp java/flease/dist/Flease.jar $(XTREEMFS_JAR_DIR) + @cp java/lib/*.jar $(XTREEMFS_JAR_DIR) + + @mkdir -p $(BIN_DIR) + @cp -p `ls $(XTREEMFS_BINARIES_DIR)/xtfs_* | grep -v xtfs_.*mount` $(BIN_DIR) + + @mkdir -p $(MAN_DIR) + @cp -R man/man1/xtfs_* $(MAN_DIR) + +uninstall: + + @rm -rf $(DOC_DIR_SERVER) + @rm -rf $(DOC_DIR_CLIENT) + @rm -rf $(DOC_DIR_TOOLS) + + @rm -rf $(BIN_DIR)/xtfs* + @rm -rf $(BIN_DIR)/*.xtreemfs + + @rm -f $(SBIN_DIR)/mount.xtreemfs + @rm -f $(SBIN_DIR)/umount.xtreemfs + + @rm -f $(XTREEMFS_JAR_DIR)/XtreemFS.jar + @rm -f $(XTREEMFS_JAR_DIR)/Foundation.jar + @rm -f $(XTREEMFS_JAR_DIR)/Flease.jar + @rm -f $(XTREEMFS_JAR_DIR)/BabuDB.jar + @rm -f $(XTREEMFS_JAR_DIR)/commons-codec-1.3.jar + @rm -f $(XTREEMFS_JAR_DIR)/jdmkrt.jar + @rm -f $(XTREEMFS_JAR_DIR)/jdmktk.jar + @rm -f $(XTREEMFS_JAR_DIR)/protobuf-java-2.5.0.jar + @rm -f $(XTREEMFS_JAR_DIR)/BabuDB_replication_plugin.jar + + @rm -f $(XTREEMFS_INIT_DIR)/xtreemfs-* + + @rm -rf $(MAN_DIR)/xtfs* + @rm -rf $(MAN_DIR)/*.xtreemfs* + + @echo "uninstall complete" + +purge: uninstall + + @rm -rf $(XTREEMFS_CONFIG_DIR) + @echo "purge complete" + +check_server: + @if [ ! -e $(JAVAC_BIN) ]; then echo "javac not found! Make sure a JDK is installed and set JAVA_HOME."; exit 1; fi; + @if [ $(shell $(JAVAC_BIN) -version 2>&1 | head -n1 | cut -d" " -f2 | cut -d. -f2) -lt 6 ]; then echo "java version >= 1.6.0 required!"; exit 1; fi; + @echo "java ok" + + @if [ ! -e $(ANT_BIN) ]; then echo "ant not found! Make sure ant is installed and set ANT_HOME."; exit 1; fi; + @echo "ant ok" + +check_client: + @if [ ! $(WHICH_GPP) -a ! $(WHICH_CLANGPP) ]; then echo "C++ compiler not found";exit 1; fi; + @if [ ! $(CMAKE_BIN) ]; then echo "cmake not found";exit 1; fi; + @echo "C++ ok" + + +check_test: + @if [[ $(shell python -V 2>&1 | head -n1 | cut -d" " -f2 | cut -d. -f2) -lt 3 && $(shell python -V 2>&1 | head -n1 | cut -d" " -f2 | cut -d. -f1) -lt 3 ]]; then echo "python >= 2.4 required!"; exit 1; fi; + @echo "python ok" + +set_version: +# Try to set the SVN revision and branch name as part of the version. We don't care if this may fail. +ifndef SKIP_SET_SVN_VERSION + @./packaging/set_version.sh -s &>/dev/null; exit 0 +endif + +.PHONY: client client_clean client_distclean client_thirdparty_clean client_package_macosx + +# Client section. +CLIENT_THIRDPARTY_REQUIREMENTS = $(CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY) +ifdef BUILD_CLIENT_TESTS + CLIENT_THIRDPARTY_REQUIREMENTS += $(CLIENT_GOOGLE_TEST_CPP_LIBRARY) $(CLIENT_GOOGLE_TEST_CPP_MAIN) + CMAKE_BUILD_CLIENT_TESTS = -DBUILD_CLIENT_TESTS=true +endif + +# Do not use env variables to control the CMake behavior as stated in http://www.cmake.org/Wiki/CMake_FAQ#How_can_I_get_or_set_environment_variables.3F +# Instead define them via -D, so they will be cached. +ifdef BOOST_ROOT + CMAKE_BOOST_ROOT = -DBOOST_ROOT="$(BOOST_ROOT)" -DBoost_NO_SYSTEM_PATHS=ON +endif +# Tell CMake if it should ignore a missing Fuse. +ifdef SKIP_FUSE + CMAKE_SKIP_FUSE = -DSKIP_FUSE=true +endif +# Trigger building the experimental LD_PRELOAD library +ifdef BUILD_PRELOAD + CMAKE_BUILD_PRELOAD = -DBUILD_PRELOAD=true +endif + + +client_thirdparty: $(CLIENT_THIRDPARTY_REQUIREMENTS) + +$(CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY): $(CLIENT_GOOGLE_PROTOBUF_CPP)/src/** + @echo "client_thirdparty: Configuring and building required Google protobuf library..." + @cd $(CLIENT_GOOGLE_PROTOBUF_CPP) && LIBS=-lpthread ./configure $(PROTOBUF_DISABLE_64_BIT_SOLARIS) >/dev/null + @$(MAKE) -C $(CLIENT_GOOGLE_PROTOBUF_CPP) >/dev/null + @echo "client_thirdparty: ...completed building required Google protobuf library." + @touch $(CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY) + +$(CLIENT_GOOGLE_TEST_CPP_LIBRARY): $(CLIENT_GOOGLE_TEST_CHECKFILE) + @touch $(CLIENT_GOOGLE_TEST_CPP_LIBRARY) + +$(CLIENT_GOOGLE_TEST_CPP_MAIN): $(CLIENT_GOOGLE_TEST_CHECKFILE) + @touch $(CLIENT_GOOGLE_TEST_CPP_MAIN) + +$(CLIENT_GOOGLE_TEST_CHECKFILE): $(CLIENT_GOOGLE_TEST_CPP)/include/** $(CLIENT_GOOGLE_TEST_CPP)/src/** + @echo "client_thirdparty: Configuring and building required Google googletest library..." + @cd $(CLIENT_GOOGLE_TEST_CPP) && ./configure >/dev/null + @$(MAKE) -C $(CLIENT_GOOGLE_TEST_CPP) >/dev/null + @touch $(CLIENT_GOOGLE_TEST_CPP_LIBRARY) + @echo "client_thirdparty: ...completed building required Google googletest library." + @touch $(CLIENT_GOOGLE_TEST_CHECKFILE) + +client_thirdparty_clean: + @if [ -f $(CLIENT_GOOGLE_PROTOBUF_CPP)/Makefile ]; then echo "Cleaning required Google protobuf library sources..."; $(MAKE) -C $(CLIENT_GOOGLE_PROTOBUF_CPP) clean >/dev/null; fi + @if [ -f $(shell pwd)/$(CLIENT_GOOGLE_TEST_CPP)/Makefile ]; then echo "Cleaning required Google googletest library sources..."; $(MAKE) -C $(shell pwd)/$(CLIENT_GOOGLE_TEST_CPP) clean >/dev/null; fi + @if [ -f $(CLIENT_GOOGLE_TEST_CHECKFILE) ]; then rm $(CLIENT_GOOGLE_TEST_CHECKFILE); fi + @echo "...finished cleaning thirdparty sources." + +client_thirdparty_distclean: + @echo "client_thirdparty: Dist-Cleaning required Google protobuf library sources..." + @if [ -f $(shell pwd)/$(CLIENT_GOOGLE_PROTOBUF_CPP)/Makefile ]; then $(MAKE) -C $(shell pwd)/$(CLIENT_GOOGLE_PROTOBUF_CPP) distclean >/dev/null; fi + @echo "client_thirdparty: Dist-Cleaning required Google googletest library sources..." + @if [ -f $(shell pwd)/$(CLIENT_GOOGLE_TEST_CPP)/Makefile ]; then $(MAKE) -C $(shell pwd)/$(CLIENT_GOOGLE_TEST_CPP) distclean >/dev/null; fi + @if [ -f $(CLIENT_GOOGLE_TEST_CHECKFILE) ]; then rm $(CLIENT_GOOGLE_TEST_CHECKFILE); fi + @echo "client_thirdparty: ...finished distcleaning thirdparty sources." + +client_debug: CLIENT_DEBUG = -DCMAKE_BUILD_TYPE=Debug +client_debug: client + +client: check_client client_thirdparty set_version + $(CMAKE_BIN) -Hcpp -B$(XTREEMFS_CLIENT_BUILD_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 $(CLIENT_DEBUG) $(CMAKE_BOOST_ROOT) $(CMAKE_BUILD_CLIENT_TESTS) $(CMAKE_SKIP_FUSE) ${CMAKE_BUILD_PRELOAD} + @$(MAKE) -C $(XTREEMFS_CLIENT_BUILD_DIR) + @cd $(XTREEMFS_CLIENT_BUILD_DIR); for i in *.xtreemfs xtfsutil; do [ -f $(XTREEMFS_BINARIES_DIR)/$$i ] && rm -f $(XTREEMFS_BINARIES_DIR)/$$i; done; true + @cp -p $(XTREEMFS_CLIENT_BUILD_DIR)/*.xtreemfs $(XTREEMFS_BINARIES_DIR) + @cp -p $(XTREEMFS_CLIENT_BUILD_DIR)/xtfsutil $(XTREEMFS_BINARIES_DIR) + +client_clean: check_client client_thirdparty_clean + @cd $(XTREEMFS_CLIENT_BUILD_DIR) &>/dev/null && { for i in *.xtreemfs xtfsutil; do [ -f $(XTREEMFS_BINARIES_DIR)/$$i ] && rm -f $(XTREEMFS_BINARIES_DIR)/$$i; done }; true + @rm -rf $(XTREEMFS_CLIENT_BUILD_DIR) + +client_distclean: check_client client_thirdparty_distclean + @cd $(XTREEMFS_CLIENT_BUILD_DIR) &>/dev/null && { for i in *.xtreemfs xtfsutil; do [ -f $(XTREEMFS_BINARIES_DIR)/$$i ] && rm -f $(XTREEMFS_BINARIES_DIR)/$$i; done }; true + @rm -rf $(XTREEMFS_CLIENT_BUILD_DIR) + +CLIENT_PACKAGE_MACOSX_OUTPUT_DIR = XtreemFS_Client_MacOSX.mpkg +CLIENT_PACKAGE_MACOSX_OUTPUT_FILE = XtreemFS_Client_MacOSX_installer.dmg +client_package_macosx: +ifeq ($(CMAKE_BOOST_ROOT),) + @echo No BOOST_ROOT environment variable is specified. This will probably fail. Please set it first.; exit 1 +endif + @./packaging/set_version.sh -i +# Clean everything first to ensure we package a clean client. + @$(MAKE) client_distclean +# We call $(MAKE) instead of specifying the targets as requirements as its not possible to define dependencies between these two and this breaks in case of parallel builds. + @$(MAKE) client SKIP_SET_SVN_VERSION=1 + @echo "Running the Apple Packagemaker..." + @/Developer/usr/bin/packagemaker -d packaging/macosx/XtreemFS_MacOSX_Package.pmdoc/ -o $(CLIENT_PACKAGE_MACOSX_OUTPUT_DIR) + @echo "Creating a DMG file..." + @if [ -f "$(CLIENT_PACKAGE_MACOSX_OUTPUT_FILE)" ]; then echo "Removing previous file $(CLIENT_PACKAGE_MACOSX_OUTPUT_FILE)."; rm "$(CLIENT_PACKAGE_MACOSX_OUTPUT_FILE)"; fi + @hdiutil create -fs HFS+ -srcfolder "$(CLIENT_PACKAGE_MACOSX_OUTPUT_DIR)" -volname "XtreemFS Client for MacOSX" "$(CLIENT_PACKAGE_MACOSX_OUTPUT_FILE)" + @if [ -d "$(CLIENT_PACKAGE_MACOSX_OUTPUT_DIR)" ]; then echo "Cleaning up temporary files..."; rm -r "$(CLIENT_PACKAGE_MACOSX_OUTPUT_DIR)"; fi + @echo "Package file created: $(CLIENT_PACKAGE_MACOSX_OUTPUT_FILE)" + +.PHONY: flease flease_clean flease_distclean +flease: foundation + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/flease/build-1.6.5.xml jar +flease_clean: + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/flease/build-1.6.5.xml clean || exit 1; +flease_distclean: + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/flease/build-1.6.5.xml clean || exit 1; + +.PHONY: foundation foundation_clean foundation_distclean +foundation: set_version + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/foundation/build-1.6.5.xml jar +foundation_clean: + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/foundation/build-1.6.5.xml clean || exit 1; +foundation_distclean: + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/foundation/build-1.6.5.xml clean || exit 1; + +.PHONY: server server_clean server_distclean +server: check_server foundation flease + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/servers/build-1.6.5.xml jar +server_clean: check_server + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/servers/build-1.6.5.xml clean || exit 1; +server_distclean: check_server + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/servers/build-1.6.5.xml clean || exit 1; + +.PHONY: hadoop-client hadoop-client_clean hadoop-client_distclean +hadoop-client: server foundation + $(ANT_BIN) -D"file.encoding=UTF-8" -f contrib/hadoop/build.xml jar + @echo -e "\n\nHadoop Client was successfully compiled. You can find it here:\n\n\tcontrib/hadoop/dist/XtreemFSHadoopClient.jar\n\nSee the XtreemFS User Guide how to add it in Hadoop.\n" +hadoop-client_clean: + $(ANT_BIN) -D"file.encoding=UTF-8" -f contrib/hadoop/build.xml clean || exit 1 +hadoop-client_distclean: + $(ANT_BIN) -D"file.encoding=UTF-8" -f contrib/hadoop/build.xml clean || exit 1 + +test: check_test client server + python ./tests/xtestenv -c ./tests/test_config.py short + +pbrpcgen: + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/pbrpcgen/build.xml + +pbrpcgen_clean: + $(ANT_BIN) -D"file.encoding=UTF-8" -f java/pbrpcgen/build.xml clean || exit 1 + +interfaces: pbrpcgen client_thirdparty + $(MAKE) -C interface diff --git a/README.md b/README.md new file mode 100644 index 0000000..1ea3039 --- /dev/null +++ b/README.md @@ -0,0 +1,13 @@ +XtreemFS is a distributed, replicated and fault-tolerant file system for federated IT infrastructures. It is open source software licensed under the New BSD License. + +**For more information, downloads and documentation visit our website at http://www.XtreemFS.org.** + + * Website: http://www.XtreemFS.org + * Downloads (Linux, MacOSX, Windows): http://www.XtreemFS.org/download.php + * User Documentation: http://www.XtreemFS.org/userguide.php + * Mailing List: http://groups.google.com/group/xtreemfs + * Tutorial for Replication Fail-Over Demo: https://code.google.com/p/xtreemfs/wiki/ContrailSummerSchoolHandsOn2013 + +The XtreemFS project is developed by Zuse Institute Berlin. The development of the project is funded by the European Commission since 2006 under Grant Agreements No. FP6-033576, FP7-ICT-257438, and FP7-318521, as well as the German projects MoSGrid, "First We Take Berlin", FFMK, GeoMultiSens, and BBDC. + +[![Build Status](https://travis-ci.org/xtreemfs/xtreemfs.svg?branch=master)](https://travis-ci.org/xtreemfs/xtreemfs) diff --git a/Vagrantfile b/Vagrantfile new file mode 100644 index 0000000..80b9725 --- /dev/null +++ b/Vagrantfile @@ -0,0 +1,129 @@ +# -*- mode: ruby -*- +# vi: set ft=ruby : + +# Vagrantfile API/syntax version. Don't touch unless you know what you're doing! +VAGRANTFILE_API_VERSION = "2" + +Vagrant.configure(VAGRANTFILE_API_VERSION) do |config| + # All Vagrant configuration is done here. The most common configuration + # options are documented and commented below. For a complete reference, + # please see the online documentation at vagrantup.com. + + # Every Vagrant virtual environment requires a box to build off of. + config.vm.box = "precise64" + + # The url from where the 'config.vm.box' box will be fetched if it + # doesn't already exist on the user's system. + config.vm.box_url = "http://files.vagrantup.com/precise64.box" + + # Create a forwarded port mapping which allows access to a specific port + # within the machine from a port on the host machine. In the example below, + # accessing "localhost:8080" will access port 80 on the guest machine. + # config.vm.network :forwarded_port, guest: 80, host: 8080 + + config.vm.network :forwarded_port, guest: 30636, host: 30636 + config.vm.network :forwarded_port, guest: 32636, host: 32636 + config.vm.network :forwarded_port, guest: 30638, host: 30638 + config.vm.network :forwarded_port, guest: 32638, host: 32638 + config.vm.network :forwarded_port, guest: 30640, host: 30640 + config.vm.network :forwarded_port, guest: 32640, host: 32640 + + # Create a private network, which allows host-only access to the machine + # using a specific IP. + # config.vm.network :private_network, ip: "192.168.33.10" + + # Create a public network, which generally matched to bridged network. + # Bridged networks make the machine appear as another physical device on + # your network. + # config.vm.network :public_network + + # If true, then any SSH connections made will enable agent forwarding. + # Default value: false + # config.ssh.forward_agent = true + + # Share an additional folder to the guest VM. The first argument is + # the path on the host to the actual folder. The second argument is + # the path on the guest to mount the folder. And the optional third + # argument is a set of non-required options. + + config.vm.synced_folder ".", "/vagrant", disabled: true + config.vm.synced_folder ".", "/xtreemfs_src" + + # Provider-specific configuration so you can fine-tune various + # backing providers for Vagrant. These expose provider-specific options. + # Example for VirtualBox: + # + # config.vm.provider :virtualbox do |vb| + # # Don't boot with headless mode + # vb.gui = true + # + # # Use VBoxManage to customize the VM. For example to change memory: + # vb.customize ["modifyvm", :id, "--memory", "1024"] + # end + # + # View the documentation for the provider you're using for more + # information on available options. + + # Enable provisioning with Puppet stand alone. Puppet manifests + # are contained in a directory path relative to this Vagrantfile. + # You will need to create the manifests directory and a manifest in + # the file precise64.pp in the manifests_path directory. + # + # An example Puppet manifest to provision the message of the day: + # + # # group { "puppet": + # # ensure => "present", + # # } + # # + # # File { owner => 0, group => 0, mode => 0644 } + # # + # # file { '/etc/motd': + # # content => "Welcome to your Vagrant-built virtual machine! + # # Managed by Puppet.\n" + # # } + # + # config.vm.provision :puppet do |puppet| + # puppet.manifests_path = "manifests" + # puppet.manifest_file = "site.pp" + # end + + # Enable provisioning with chef solo, specifying a cookbooks path, roles + # path, and data_bags path (all relative to this Vagrantfile), and adding + # some recipes and/or roles. + # + # config.vm.provision :chef_solo do |chef| + # chef.cookbooks_path = "../my-recipes/cookbooks" + # chef.roles_path = "../my-recipes/roles" + # chef.data_bags_path = "../my-recipes/data_bags" + # chef.add_recipe "mysql" + # chef.add_role "web" + # + # # You may also specify custom JSON attributes: + # chef.json = { :mysql_password => "foo" } + # end + + # Enable provisioning with chef server, specifying the chef server URL, + # and the path to the validation key (relative to this Vagrantfile). + # + # The Opscode Platform uses HTTPS. Substitute your organization for + # ORGNAME in the URL and validation key. + # + # If you have your own Chef Server, use the appropriate URL, which may be + # HTTP instead of HTTPS depending on your configuration. Also change the + # validation key to validation.pem. + # + # config.vm.provision :chef_client do |chef| + # chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME" + # chef.validation_key_path = "ORGNAME-validator.pem" + # end + # + # If you're using the Opscode platform, your validator client is + # ORGNAME-validator, replacing ORGNAME with your organization name. + # + # If you have your own Chef Server, the default validation client name is + # chef-validator, unless you changed the configuration. + # + # chef.validation_client_name = "ORGNAME-validator" + + config.vm.provision "shell", path: "contrib/vagrant/provision.sh" +end diff --git a/bin/cpplint.py b/bin/cpplint.py new file mode 100755 index 0000000..188f8ea --- /dev/null +++ b/bin/cpplint.py @@ -0,0 +1,2725 @@ +#!/usr/bin/python +# +# cpplint.py is Copyright (C) 2009 Google Inc. +# +# It is free software; you can redistribute it and/or modify it under the +# terms of either: +# +# a) the GNU General Public License as published by the Free Software +# Foundation; either version 1, or (at your option) any later version, or +# +# b) the "Artistic License". + +# Here are some issues that I've had people identify in my code during reviews, +# that I think are possible to flag automatically in a lint tool. If these were +# caught by lint, it would save time both for myself and that of my reviewers. +# Most likely, some of these are beyond the scope of the current lint framework, +# but I think it is valuable to retain these wish-list items even if they cannot +# be immediately implemented. +# +# Suggestions +# ----------- +# - Check for no 'explicit' for multi-arg ctor +# - Check for boolean assign RHS in parens +# - Check for ctor initializer-list colon position and spacing +# - Check that if there's a ctor, there should be a dtor +# - Check accessors that return non-pointer member variables are +# declared const +# - Check accessors that return non-const pointer member vars are +# *not* declared const +# - Check for using public includes for testing +# - Check for spaces between brackets in one-line inline method +# - Check for no assert() +# - Check for spaces surrounding operators +# - Check for 0 in pointer context (should be NULL) +# - Check for 0 in char context (should be '\0') +# - Check for camel-case method name conventions for methods +# that are not simple inline getters and setters +# - Check that base classes have virtual destructors +# put " // namespace" after } that closes a namespace, with +# namespace's name after 'namespace' if it is named. +# - Do not indent namespace contents +# - Avoid inlining non-trivial constructors in header files +# include base/basictypes.h if DISALLOW_EVIL_CONSTRUCTORS is used +# - Check for old-school (void) cast for call-sites of functions +# ignored return value +# - Check gUnit usage of anonymous namespace +# - Check for class declaration order (typedefs, consts, enums, +# ctor(s?), dtor, friend declarations, methods, member vars) +# + +"""Does google-lint on c++ files. + +The goal of this script is to identify places in the code that *may* +be in non-compliance with google style. It does not attempt to fix +up these problems -- the point is to educate. It does also not +attempt to find all problems, or to ensure that everything it does +find is legitimately a problem. + +In particular, we can get very confused by /* and // inside strings! +We do a small hack, which is to ignore //'s with "'s after them on the +same line, but it is far from perfect (in either direction). +""" + +import codecs +import getopt +import math # for log +import os +import re +import sre_compile +import string +import sys +import unicodedata + + +_USAGE = """ +Syntax: cpplint.py [--verbose=#] [--output=vs7] [--filter=-x,+y,...] + [file] ... + + The style guidelines this tries to follow are those in + http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml + + Every problem is given a confidence score from 1-5, with 5 meaning we are + certain of the problem, and 1 meaning it could be a legitimate construct. + This will miss some errors, and is not a substitute for a code review. + + To prevent specific lines from being linted, add a '// NOLINT' comment to the + end of the line. + + The files passed in will be linted; at least one file must be provided. + Linted extensions are .cc, .cpp, and .h. Other file types will be ignored. + + Flags: + + output=vs7 + By default, the output is formatted to ease emacs parsing. Visual Studio + compatible output (vs7) may also be used. Other formats are unsupported. + + verbose=# + Specify a number 0-5 to restrict errors to certain verbosity levels. + + filter=-x,+y,... + Specify a comma-separated list of category-filters to apply: only + error messages whose category names pass the filters will be printed. + (Category names are printed with the message and look like + "[whitespace/indent]".) Filters are evaluated left to right. + "-FOO" and "FOO" means "do not print categories that start with FOO". + "+FOO" means "do print categories that start with FOO". + + Examples: --filter=-whitespace,+whitespace/braces + --filter=whitespace,runtime/printf,+runtime/printf_format + --filter=-,+build/include_what_you_use + + To see a list of all the categories used in cpplint, pass no arg: + --filter= +""" + +# We categorize each error message we print. Here are the categories. +# We want an explicit list so we can list them all in cpplint --filter=. +# If you add a new error message with a new category, add it to the list +# here! cpplint_unittest.py should tell you if you forget to do this. +_ERROR_CATEGORIES = """\ + build/class + build/deprecated + build/endif_comment + build/forward_decl + build/header_guard + build/include + build/include_order + build/include_what_you_use + build/namespaces + build/printf_format + build/storage_class + legal/copyright + readability/braces + readability/casting + readability/check + readability/constructors + readability/fn_size + readability/function + readability/multiline_comment + readability/multiline_string + readability/streams + readability/todo + readability/utf8 + runtime/arrays + runtime/casting + runtime/explicit + runtime/int + runtime/init + runtime/memset + runtime/printf + runtime/printf_format + runtime/references + runtime/rtti + runtime/sizeof + runtime/string + runtime/threadsafe_fn + runtime/virtual + whitespace/blank_line + whitespace/braces + whitespace/comma + whitespace/comments + whitespace/end_of_line + whitespace/ending_newline + whitespace/indent + whitespace/labels + whitespace/line_length + whitespace/newline + whitespace/operators + whitespace/parens + whitespace/semicolon + whitespace/tab + whitespace/todo +""" + +# We used to check for high-bit characters, but after much discussion we +# decided those were OK, as long as they were in UTF-8 and didn't represent +# hard-coded international strings, which belong in a seperate i18n file. + +# Headers that we consider STL headers. +_STL_HEADERS = frozenset([ + 'algobase.h', 'algorithm', 'alloc.h', 'bitset', 'deque', 'exception', + 'function.h', 'functional', 'hash_map', 'hash_map.h', 'hash_set', + 'hash_set.h', 'iterator', 'list', 'list.h', 'map', 'memory', 'pair.h', + 'pthread_alloc', 'queue', 'set', 'set.h', 'sstream', 'stack', + 'stl_alloc.h', 'stl_relops.h', 'type_traits.h', + 'utility', 'vector', 'vector.h', + ]) + + +# Non-STL C++ system headers. +_CPP_HEADERS = frozenset([ + 'algo.h', 'builtinbuf.h', 'bvector.h', 'cassert', 'cctype', + 'cerrno', 'cfloat', 'ciso646', 'climits', 'clocale', 'cmath', + 'complex', 'complex.h', 'csetjmp', 'csignal', 'cstdarg', 'cstddef', + 'cstdio', 'cstdlib', 'cstring', 'ctime', 'cwchar', 'cwctype', + 'defalloc.h', 'deque.h', 'editbuf.h', 'exception', 'fstream', + 'fstream.h', 'hashtable.h', 'heap.h', 'indstream.h', 'iomanip', + 'iomanip.h', 'ios', 'iosfwd', 'iostream', 'iostream.h', 'istream.h', + 'iterator.h', 'limits', 'map.h', 'multimap.h', 'multiset.h', + 'numeric', 'ostream.h', 'parsestream.h', 'pfstream.h', 'PlotFile.h', + 'procbuf.h', 'pthread_alloc.h', 'rope', 'rope.h', 'ropeimpl.h', + 'SFile.h', 'slist', 'slist.h', 'stack.h', 'stdexcept', + 'stdiostream.h', 'streambuf.h', 'stream.h', 'strfile.h', 'string', + 'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo', 'valarray', + ]) + + +# Assertion macros. These are defined in base/logging.h and +# testing/base/gunit.h. Note that the _M versions need to come first +# for substring matching to work. +_CHECK_MACROS = [ + 'CHECK', + 'EXPECT_TRUE_M', 'EXPECT_TRUE', + 'ASSERT_TRUE_M', 'ASSERT_TRUE', + 'EXPECT_FALSE_M', 'EXPECT_FALSE', + 'ASSERT_FALSE_M', 'ASSERT_FALSE', + ] + +# Replacement macros for CHECK/EXPECT_TRUE/EXPECT_FALSE +_CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS]) + +for op, replacement in [('==', 'EQ'), ('!=', 'NE'), + ('>=', 'GE'), ('>', 'GT'), + ('<=', 'LE'), ('<', 'LT')]: + _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement + _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement + _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement + _CHECK_REPLACEMENT['EXPECT_TRUE_M'][op] = 'EXPECT_%s_M' % replacement + _CHECK_REPLACEMENT['ASSERT_TRUE_M'][op] = 'ASSERT_%s_M' % replacement + +for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'), + ('>=', 'LT'), ('>', 'LE'), + ('<=', 'GT'), ('<', 'GE')]: + _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement + _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement + _CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement + _CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement + + +# These constants define types of headers for use with +# _IncludeState.CheckNextIncludeOrder(). +_C_SYS_HEADER = 1 +_CPP_SYS_HEADER = 2 +_LIKELY_MY_HEADER = 3 +_POSSIBLE_MY_HEADER = 4 +_OTHER_HEADER = 5 + + +_regexp_compile_cache = {} + + +def Match(pattern, s): + """Matches the string with the pattern, caching the compiled regexp.""" + # The regexp compilation caching is inlined in both Match and Search for + # performance reasons; factoring it out into a separate function turns out + # to be noticeably expensive. + if not pattern in _regexp_compile_cache: + _regexp_compile_cache[pattern] = sre_compile.compile(pattern) + return _regexp_compile_cache[pattern].match(s) + + +def Search(pattern, s): + """Searches the string for the pattern, caching the compiled regexp.""" + if not pattern in _regexp_compile_cache: + _regexp_compile_cache[pattern] = sre_compile.compile(pattern) + return _regexp_compile_cache[pattern].search(s) + + +class _IncludeState(dict): + """Tracks line numbers for includes, and the order in which includes appear. + + As a dict, an _IncludeState object serves as a mapping between include + filename and line number on which that file was included. + + Call CheckNextIncludeOrder() once for each header in the file, passing + in the type constants defined above. Calls in an illegal order will + raise an _IncludeError with an appropriate error message. + + """ + # self._section will move monotonically through this set. If it ever + # needs to move backwards, CheckNextIncludeOrder will raise an error. + _INITIAL_SECTION = 0 + _MY_H_SECTION = 1 + _C_SECTION = 2 + _CPP_SECTION = 3 + _OTHER_H_SECTION = 4 + + _TYPE_NAMES = { + _C_SYS_HEADER: 'C system header', + _CPP_SYS_HEADER: 'C++ system header', + _LIKELY_MY_HEADER: 'header this file implements', + _POSSIBLE_MY_HEADER: 'header this file may implement', + _OTHER_HEADER: 'other header', + } + _SECTION_NAMES = { + _INITIAL_SECTION: "... nothing. (This can't be an error.)", + _MY_H_SECTION: 'a header this file implements', + _C_SECTION: 'C system header', + _CPP_SECTION: 'C++ system header', + _OTHER_H_SECTION: 'other header', + } + + def __init__(self): + dict.__init__(self) + self._section = self._INITIAL_SECTION + + def CheckNextIncludeOrder(self, header_type): + """Returns a non-empty error message if the next header is out of order. + + This function also updates the internal state to be ready to check + the next include. + + Args: + header_type: One of the _XXX_HEADER constants defined above. + + Returns: + The empty string if the header is in the right order, or an + error message describing what's wrong. + + """ + error_message = ('Found %s after %s' % + (self._TYPE_NAMES[header_type], + self._SECTION_NAMES[self._section])) + + if header_type == _C_SYS_HEADER: + if self._section <= self._C_SECTION: + self._section = self._C_SECTION + else: + return error_message + elif header_type == _CPP_SYS_HEADER: + if self._section <= self._CPP_SECTION: + self._section = self._CPP_SECTION + else: + return error_message + elif header_type == _LIKELY_MY_HEADER: + if self._section <= self._MY_H_SECTION: + self._section = self._MY_H_SECTION + else: + self._section = self._OTHER_H_SECTION + elif header_type == _POSSIBLE_MY_HEADER: + if self._section <= self._MY_H_SECTION: + self._section = self._MY_H_SECTION + else: + # This will always be the fallback because we're not sure + # enough that the header is associated with this file. + self._section = self._OTHER_H_SECTION + else: + assert header_type == _OTHER_HEADER + self._section = self._OTHER_H_SECTION + + return '' + + +class _CppLintState(object): + """Maintains module-wide state..""" + + def __init__(self): + self.verbose_level = 1 # global setting. + self.error_count = 0 # global count of reported errors + self.filters = [] # filters to apply when emitting error messages + + # output format: + # "emacs" - format that emacs can parse (default) + # "vs7" - format that Microsoft Visual Studio 7 can parse + self.output_format = 'emacs' + + def SetOutputFormat(self, output_format): + """Sets the output format for errors.""" + self.output_format = output_format + + def SetVerboseLevel(self, level): + """Sets the module's verbosity, and returns the previous setting.""" + last_verbose_level = self.verbose_level + self.verbose_level = level + return last_verbose_level + + def SetFilters(self, filters): + """Sets the error-message filters. + + These filters are applied when deciding whether to emit a given + error message. + + Args: + filters: A string of comma-separated filters (eg "+whitespace/indent"). + Each filter should start with + or -; else we die. + """ + if not filters: + self.filters = [] + else: + self.filters = filters.split(',') + for filt in self.filters: + if not (filt.startswith('+') or filt.startswith('-')): + raise ValueError('Every filter in --filters must start with + or -' + ' (%s does not)' % filt) + + def ResetErrorCount(self): + """Sets the module's error statistic back to zero.""" + self.error_count = 0 + + def IncrementErrorCount(self): + """Bumps the module's error statistic.""" + self.error_count += 1 + + +_cpplint_state = _CppLintState() + + +def _OutputFormat(): + """Gets the module's output format.""" + return _cpplint_state.output_format + + +def _SetOutputFormat(output_format): + """Sets the module's output format.""" + _cpplint_state.SetOutputFormat(output_format) + + +def _VerboseLevel(): + """Returns the module's verbosity setting.""" + return _cpplint_state.verbose_level + + +def _SetVerboseLevel(level): + """Sets the module's verbosity, and returns the previous setting.""" + return _cpplint_state.SetVerboseLevel(level) + + +def _Filters(): + """Returns the module's list of output filters, as a list.""" + return _cpplint_state.filters + + +def _SetFilters(filters): + """Sets the module's error-message filters. + + These filters are applied when deciding whether to emit a given + error message. + + Args: + filters: A string of comma-separated filters (eg "whitespace/indent"). + Each filter should start with + or -; else we die. + """ + _cpplint_state.SetFilters(filters) + + +class _FunctionState(object): + """Tracks current function name and the number of lines in its body.""" + + _NORMAL_TRIGGER = 250 # for --v=0, 500 for --v=1, etc. + _TEST_TRIGGER = 400 # about 50% more than _NORMAL_TRIGGER. + + def __init__(self): + self.in_a_function = False + self.lines_in_function = 0 + self.current_function = '' + + def Begin(self, function_name): + """Start analyzing function body. + + Args: + function_name: The name of the function being tracked. + """ + self.in_a_function = True + self.lines_in_function = 0 + self.current_function = function_name + + def Count(self): + """Count line in current function body.""" + if self.in_a_function: + self.lines_in_function += 1 + + def Check(self, error, filename, linenum): + """Report if too many lines in function body. + + Args: + error: The function to call with any errors found. + filename: The name of the current file. + linenum: The number of the line to check. + """ + if Match(r'T(EST|est)', self.current_function): + base_trigger = self._TEST_TRIGGER + else: + base_trigger = self._NORMAL_TRIGGER + trigger = base_trigger * 2**_VerboseLevel() + + if self.lines_in_function > trigger: + error_level = int(math.log(self.lines_in_function / base_trigger, 2)) + # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ... + if error_level > 5: + error_level = 5 + error(filename, linenum, 'readability/fn_size', error_level, + 'Small and focused functions are preferred:' + ' %s has %d non-comment lines' + ' (error triggered by exceeding %d lines).' % ( + self.current_function, self.lines_in_function, trigger)) + + def End(self): + """Stop analizing function body.""" + self.in_a_function = False + + +class _IncludeError(Exception): + """Indicates a problem with the include order in a file.""" + pass + + +class FileInfo: + """Provides utility functions for filenames. + + FileInfo provides easy access to the components of a file's path + relative to the project root. + """ + + def __init__(self, filename): + self._filename = filename + + def FullName(self): + """Make Windows paths like Unix.""" + return os.path.abspath(self._filename).replace('\\', '/') + + def RepositoryName(self): + """FullName after removing the local path to the repository. + + If we have a real absolute path name here we can try to do something smart: + detecting the root of the checkout and truncating /path/to/checkout from + the name so that we get header guards that don't include things like + "C:\Documents and Settings\..." or "/home/username/..." in them and thus + people on different computers who have checked the source out to different + locations won't see bogus errors. + """ + fullname = self.FullName() + + if os.path.exists(fullname): + project_dir = os.path.dirname(fullname) + + if os.path.exists(os.path.join(project_dir, ".svn")): + # If there's a .svn file in the current directory, we recursively look + # up the directory tree for the top of the SVN checkout + root_dir = project_dir + one_up_dir = os.path.dirname(root_dir) + while os.path.exists(os.path.join(one_up_dir, ".svn")): + root_dir = os.path.dirname(root_dir) + one_up_dir = os.path.dirname(one_up_dir) + + prefix = os.path.commonprefix([root_dir, project_dir]) + return fullname[len(prefix) + 1:] + + # Not SVN? Try to find a git top level directory by searching up from the + # current path. + root_dir = os.path.dirname(fullname) + while (root_dir != os.path.dirname(root_dir) and + not os.path.exists(os.path.join(root_dir, ".git"))): + root_dir = os.path.dirname(root_dir) + if os.path.exists(os.path.join(root_dir, ".git")): + prefix = os.path.commonprefix([root_dir, project_dir]) + return fullname[len(prefix) + 1:] + + # Don't know what to do; header guard warnings may be wrong... + return fullname + + def Split(self): + """Splits the file into the directory, basename, and extension. + + For 'chrome/browser/browser.cc', Split() would + return ('chrome/browser', 'browser', '.cc') + + Returns: + A tuple of (directory, basename, extension). + """ + + googlename = self.RepositoryName() + project, rest = os.path.split(googlename) + return (project,) + os.path.splitext(rest) + + def BaseName(self): + """File base name - text after the final slash, before the final period.""" + return self.Split()[1] + + def Extension(self): + """File extension - text following the final period.""" + return self.Split()[2] + + def NoExtension(self): + """File has no source file extension.""" + return '/'.join(self.Split()[0:2]) + + def IsSource(self): + """File has a source file extension.""" + return self.Extension()[1:] in ('c', 'cc', 'cpp', 'cxx') + + +def _ShouldPrintError(category, confidence): + """Returns true iff confidence >= verbose, and category passes filter.""" + # There are two ways we might decide not to print an error message: + # the verbosity level isn't high enough, or the filters filter it out. + if confidence < _cpplint_state.verbose_level: + return False + + is_filtered = False + for one_filter in _Filters(): + if one_filter.startswith('-'): + if category.startswith(one_filter[1:]): + is_filtered = True + elif one_filter.startswith('+'): + if category.startswith(one_filter[1:]): + is_filtered = False + else: + assert False # should have been checked for in SetFilter. + if is_filtered: + return False + + return True + + +def Error(filename, linenum, category, confidence, message): + """Logs the fact we've found a lint error. + + We log where the error was found, and also our confidence in the error, + that is, how certain we are this is a legitimate style regression, and + not a misidentification or a use that's sometimes justified. + + Args: + filename: The name of the file containing the error. + linenum: The number of the line containing the error. + category: A string used to describe the "category" this bug + falls under: "whitespace", say, or "runtime". Categories + may have a hierarchy separated by slashes: "whitespace/indent". + confidence: A number from 1-5 representing a confidence score for + the error, with 5 meaning that we are certain of the problem, + and 1 meaning that it could be a legitimate construct. + message: The error message. + """ + # There are two ways we might decide not to print an error message: + # the verbosity level isn't high enough, or the filters filter it out. + if _ShouldPrintError(category, confidence): + _cpplint_state.IncrementErrorCount() + if _cpplint_state.output_format == 'vs7': + sys.stderr.write('%s(%s): %s [%s] [%d]\n' % ( + filename, linenum, message, category, confidence)) + else: + sys.stderr.write('%s:%s: %s [%s] [%d]\n' % ( + filename, linenum, message, category, confidence)) + + +# Matches standard C++ escape esequences per 2.13.2.3 of the C++ standard. +_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile( + r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)') +# Matches strings. Escape codes should already be removed by ESCAPES. +_RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES = re.compile(r'"[^"]*"') +# Matches characters. Escape codes should already be removed by ESCAPES. +_RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES = re.compile(r"'.'") +# Matches multi-line C++ comments. +# This RE is a little bit more complicated than one might expect, because we +# have to take care of space removals tools so we can handle comments inside +# statements better. +# The current rule is: We only clear spaces from both sides when we're at the +# end of the line. Otherwise, we try to remove spaces from the right side, +# if this doesn't work we try on left side but only if there's a non-character +# on the right. +_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile( + r"""(\s*/\*.*\*/\s*$| + /\*.*\*/\s+| + \s+/\*.*\*/(?=\W)| + /\*.*\*/)""", re.VERBOSE) + + +def IsCppString(line): + """Does line terminate so, that the next symbol is in string constant. + + This function does not consider single-line nor multi-line comments. + + Args: + line: is a partial line of code starting from the 0..n. + + Returns: + True, if next character appended to 'line' is inside a + string constant. + """ + + line = line.replace(r'\\', 'XX') # after this, \\" does not match to \" + return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1 + + +def FindNextMultiLineCommentStart(lines, lineix): + """Find the beginning marker for a multiline comment.""" + while lineix < len(lines): + if lines[lineix].strip().startswith('/*'): + # Only return this marker if the comment goes beyond this line + if lines[lineix].strip().find('*/', 2) < 0: + return lineix + lineix += 1 + return len(lines) + + +def FindNextMultiLineCommentEnd(lines, lineix): + """We are inside a comment, find the end marker.""" + while lineix < len(lines): + if lines[lineix].strip().endswith('*/'): + return lineix + lineix += 1 + return len(lines) + + +def RemoveMultiLineCommentsFromRange(lines, begin, end): + """Clears a range of lines for multi-line comments.""" + # Having // dummy comments makes the lines non-empty, so we will not get + # unnecessary blank line warnings later in the code. + for i in range(begin, end): + lines[i] = '// dummy' + + +def RemoveMultiLineComments(filename, lines, error): + """Removes multiline (c-style) comments from lines.""" + lineix = 0 + while lineix < len(lines): + lineix_begin = FindNextMultiLineCommentStart(lines, lineix) + if lineix_begin >= len(lines): + return + lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin) + if lineix_end >= len(lines): + error(filename, lineix_begin + 1, 'readability/multiline_comment', 5, + 'Could not find end of multi-line comment') + return + RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + 1) + lineix = lineix_end + 1 + + +def CleanseComments(line): + """Removes //-comments and single-line C-style /* */ comments. + + Args: + line: A line of C++ source. + + Returns: + The line with single-line comments removed. + """ + commentpos = line.find('//') + if commentpos != -1 and not IsCppString(line[:commentpos]): + line = line[:commentpos] + # get rid of /* ... */ + return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line) + + +class CleansedLines: + """Holds 3 copies of all lines with different preprocessing applied to them. + + 1) elided member contains lines without strings and comments, + 2) lines member contains lines without comments, and + 3) raw member contains all the lines without processing. + All these three members are of , and of the same length. + """ + + def __init__(self, lines): + self.elided = [] + self.lines = [] + self.raw_lines = lines + self.num_lines = len(lines) + for linenum in range(len(lines)): + self.lines.append(CleanseComments(lines[linenum])) + elided = self._CollapseStrings(lines[linenum]) + self.elided.append(CleanseComments(elided)) + + def NumLines(self): + """Returns the number of lines represented.""" + return self.num_lines + + @staticmethod + def _CollapseStrings(elided): + """Collapses strings and chars on a line to simple "" or '' blocks. + + We nix strings first so we're not fooled by text like '"http://"' + + Args: + elided: The line being processed. + + Returns: + The line with collapsed strings. + """ + if not _RE_PATTERN_INCLUDE.match(elided): + # Remove escaped characters first to make quote/single quote collapsing + # basic. Things that look like escaped characters shouldn't occur + # outside of strings and chars. + elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided) + elided = _RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES.sub("''", elided) + elided = _RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES.sub('""', elided) + return elided + + +def CloseExpression(clean_lines, linenum, pos): + """If input points to ( or { or [, finds the position that closes it. + + If lines[linenum][pos] points to a '(' or '{' or '[', finds the the + linenum/pos that correspond to the closing of the expression. + + Args: + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + pos: A position on the line. + + Returns: + A tuple (line, linenum, pos) pointer *past* the closing brace, or + (line, len(lines), -1) if we never find a close. Note we ignore + strings and comments when matching; and the line we return is the + 'cleansed' line at linenum. + """ + + line = clean_lines.elided[linenum] + startchar = line[pos] + if startchar not in '({[': + return (line, clean_lines.NumLines(), -1) + if startchar == '(': endchar = ')' + if startchar == '[': endchar = ']' + if startchar == '{': endchar = '}' + + num_open = line.count(startchar) - line.count(endchar) + while linenum < clean_lines.NumLines() and num_open > 0: + linenum += 1 + line = clean_lines.elided[linenum] + num_open += line.count(startchar) - line.count(endchar) + # OK, now find the endchar that actually got us back to even + endpos = len(line) + while num_open >= 0: + endpos = line.rfind(')', 0, endpos) + num_open -= 1 # chopped off another ) + return (line, linenum, endpos + 1) + + +def CheckForCopyright(filename, lines, error): + """Logs an error if no Copyright message appears at the top of the file.""" + + # We'll say it should occur by line 10. Don't forget there's a + # dummy line at the front. + for line in xrange(1, min(len(lines), 11)): + if re.search(r'Copyright', lines[line], re.I): break + else: # means no copyright line was found + error(filename, 0, 'legal/copyright', 5, + 'No copyright message found. ' + 'You should have a line: "Copyright [year] "') + + +def GetHeaderGuardCPPVariable(filename): + """Returns the CPP variable that should be used as a header guard. + + Args: + filename: The name of a C++ header file. + + Returns: + The CPP variable that should be used as a header guard in the + named file. + + """ + + fileinfo = FileInfo(filename) + return re.sub(r'[-./\s]', '_', fileinfo.RepositoryName()).upper() + '_' + + +def CheckForHeaderGuard(filename, lines, error): + """Checks that the file contains a header guard. + + Logs an error if no #ifndef header guard is present. For google3 + headers, checks that the full pathname is used. + + Args: + filename: The name of the C++ header file. + lines: An array of strings, each representing a line of the file. + error: The function to call with any errors found. + """ + + cppvar = GetHeaderGuardCPPVariable(filename) + + ifndef = None + ifndef_linenum = 0 + define = None + endif = None + endif_linenum = 0 + for linenum, line in enumerate(lines): + linesplit = line.split() + if len(linesplit) >= 2: + # find the first occurrence of #ifndef and #define, save arg + if not ifndef and linesplit[0] == '#ifndef': + # set ifndef to the header guard presented on the #ifndef line. + ifndef = linesplit[1] + ifndef_linenum = linenum + if not define and linesplit[0] == '#define': + define = linesplit[1] + # find the last occurrence of #endif, save entire line + if line.startswith('#endif'): + endif = line + endif_linenum = linenum + + if not ifndef or not define or ifndef != define: + error(filename, 0, 'build/header_guard', 5, + 'No #ifndef header guard found, suggested CPP variable is: %s' % + cppvar) + return + + # The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__ + # for backward compatibility. + if ifndef != cppvar: + error_level = 0 + if ifndef != cppvar + '_': + error_level = 5 + + error(filename, ifndef_linenum, 'build/header_guard', error_level, + '#ifndef header guard has wrong style, please use: %s' % cppvar) + + if endif != ('#endif // %s' % cppvar): + error_level = 0 + if endif != ('#endif // %s' % (cppvar + '_')): + error_level = 5 + + error(filename, endif_linenum, 'build/header_guard', error_level, + '#endif line should be "#endif // %s"' % cppvar) + + +def CheckForUnicodeReplacementCharacters(filename, lines, error): + """Logs an error for each line containing Unicode replacement characters. + + These indicate that either the file contained invalid UTF-8 (likely) + or Unicode replacement characters (which it shouldn't). Note that + it's possible for this to throw off line numbering if the invalid + UTF-8 occurred adjacent to a newline. + + Args: + filename: The name of the current file. + lines: An array of strings, each representing a line of the file. + error: The function to call with any errors found. + """ + for linenum, line in enumerate(lines): + if u'\ufffd' in line: + error(filename, linenum, 'readability/utf8', 5, + 'Line contains invalid UTF-8 (or Unicode replacement character).') + + +def CheckForNewlineAtEOF(filename, lines, error): + """Logs an error if there is no newline char at the end of the file. + + Args: + filename: The name of the current file. + lines: An array of strings, each representing a line of the file. + error: The function to call with any errors found. + """ + + # The array lines() was created by adding two newlines to the + # original file (go figure), then splitting on \n. + # To verify that the file ends in \n, we just have to make sure the + # last-but-two element of lines() exists and is empty. + if len(lines) < 3 or lines[-2]: + error(filename, len(lines) - 2, 'whitespace/ending_newline', 5, + 'Could not find a newline character at the end of the file.') + + +def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error): + """Logs an error if we see /* ... */ or "..." that extend past one line. + + /* ... */ comments are legit inside macros, for one line. + Otherwise, we prefer // comments, so it's ok to warn about the + other. Likewise, it's ok for strings to extend across multiple + lines, as long as a line continuation character (backslash) + terminates each line. Although not currently prohibited by the C++ + style guide, it's ugly and unnecessary. We don't do well with either + in this lint program, so we warn about both. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + + # Remove all \\ (escaped backslashes) from the line. They are OK, and the + # second (escaped) slash may trigger later \" detection erroneously. + line = line.replace('\\\\', '') + + if line.count('/*') > line.count('*/'): + error(filename, linenum, 'readability/multiline_comment', 5, + 'Complex multi-line /*...*/-style comment found. ' + 'Lint may give bogus warnings. ' + 'Consider replacing these with //-style comments, ' + 'with #if 0...#endif, ' + 'or with more clearly structured multi-line comments.') + + if (line.count('"') - line.count('\\"')) % 2: + error(filename, linenum, 'readability/multiline_string', 5, + 'Multi-line string ("...") found. This lint script doesn\'t ' + 'do well with such strings, and may give bogus warnings. They\'re ' + 'ugly and unnecessary, and you should use concatenation instead".') + + +threading_list = ( + ('asctime(', 'asctime_r('), + ('ctime(', 'ctime_r('), + ('getgrgid(', 'getgrgid_r('), + ('getgrnam(', 'getgrnam_r('), + ('getlogin(', 'getlogin_r('), + ('getpwnam(', 'getpwnam_r('), + ('getpwuid(', 'getpwuid_r('), + ('gmtime(', 'gmtime_r('), + ('localtime(', 'localtime_r('), + ('rand(', 'rand_r('), + ('readdir(', 'readdir_r('), + ('strtok(', 'strtok_r('), + ('ttyname(', 'ttyname_r('), + ) + + +def CheckPosixThreading(filename, clean_lines, linenum, error): + """Checks for calls to thread-unsafe functions. + + Much code has been originally written without consideration of + multi-threading. Also, engineers are relying on their old experience; + they have learned posix before threading extensions were added. These + tests guide the engineers to use thread-safe functions (when using + posix directly). + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] + for single_thread_function, multithread_safe_function in threading_list: + ix = line.find(single_thread_function) + if ix >= 0 and (ix == 0 or (not line[ix - 1].isalnum() and + line[ix - 1] not in ('_', '.', '>'))): + error(filename, linenum, 'runtime/threadsafe_fn', 2, + 'Consider using ' + multithread_safe_function + + '...) instead of ' + single_thread_function + + '...) for improved thread safety.') + + +class _ClassInfo(object): + """Stores information about a class.""" + + def __init__(self, name, linenum): + self.name = name + self.linenum = linenum + self.seen_open_brace = False + self.is_derived = False + self.virtual_method_linenumber = None + self.has_virtual_destructor = False + self.brace_depth = 0 + + +class _ClassState(object): + """Holds the current state of the parse relating to class declarations. + + It maintains a stack of _ClassInfos representing the parser's guess + as to the current nesting of class declarations. The innermost class + is at the top (back) of the stack. Typically, the stack will either + be empty or have exactly one entry. + """ + + def __init__(self): + self.classinfo_stack = [] + + def CheckFinished(self, filename, error): + """Checks that all classes have been completely parsed. + + Call this when all lines in a file have been processed. + Args: + filename: The name of the current file. + error: The function to call with any errors found. + """ + if self.classinfo_stack: + # Note: This test can result in false positives if #ifdef constructs + # get in the way of brace matching. See the testBuildClass test in + # cpplint_unittest.py for an example of this. + error(filename, self.classinfo_stack[0].linenum, 'build/class', 5, + 'Failed to find complete declaration of class %s' % + self.classinfo_stack[0].name) + + +def CheckForNonStandardConstructs(filename, clean_lines, linenum, + class_state, error): + """Logs an error if we see certain non-ANSI constructs ignored by gcc-2. + + Complain about several constructs which gcc-2 accepts, but which are + not standard C++. Warning about these in lint is one way to ease the + transition to new compilers. + - put storage class first (e.g. "static const" instead of "const static"). + - "%lld" instead of %qd" in printf-type functions. + - "%1$d" is non-standard in printf-type functions. + - "\%" is an undefined character escape sequence. + - text after #endif is not allowed. + - invalid inner-style forward declaration. + - >? and ?= and )\?=?\s*(\w+|[+-]?\d+)(\.\d*)?', + line): + error(filename, linenum, 'build/deprecated', 3, + '>? and ,:]*>\s*)?(class|struct)\s+(\w+(::\w+)*)', line) + if class_decl_match: + classinfo_stack.append(_ClassInfo(class_decl_match.group(3), linenum)) + + # Everything else in this function uses the top of the stack if it's + # not empty. + if not classinfo_stack: + return + + classinfo = classinfo_stack[-1] + + # If the opening brace hasn't been seen look for it and also + # parent class declarations. + if not classinfo.seen_open_brace: + # If the line has a ';' in it, assume it's a forward declaration or + # a single-line class declaration, which we won't process. + if line.find(';') != -1: + classinfo_stack.pop() + return + classinfo.seen_open_brace = (line.find('{') != -1) + # Look for a bare ':' + if Search('(^|[^:]):($|[^:])', line): + classinfo.is_derived = True + if not classinfo.seen_open_brace: + return # Everything else in this function is for after open brace + + # The class may have been declared with namespace or classname qualifiers. + # The constructor and destructor will not have those qualifiers. + base_classname = classinfo.name.split('::')[-1] + + # Look for single-argument constructors that aren't marked explicit. + # Technically a valid construct, but against style. + args = Match(r'(? 1: + error(filename, linenum, 'whitespace/todo', 2, + 'Too many spaces before TODO') + + username = match.group(2) + if not username: + error(filename, linenum, 'readability/todo', 2, + 'Missing username in TODO; it should look like ' + '"// TODO(my_username): Stuff."') + + middle_whitespace = match.group(3) + if middle_whitespace != ' ' and middle_whitespace != '': + error(filename, linenum, 'whitespace/todo', 2, + 'TODO(my_username) should be followed by a space') + + +def CheckSpacing(filename, clean_lines, linenum, error): + """Checks for the correctness of various spacing issues in the code. + + Things we check for: spaces around operators, spaces after + if/for/while/switch, no spaces around parens in function calls, two + spaces between code and comment, don't start a block with a blank + line, don't end a function with a blank line, don't have too many + blank lines in a row. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + raw = clean_lines.raw_lines + line = raw[linenum] + + # Before nixing comments, check if the line is blank for no good + # reason. This includes the first line after a block is opened, and + # blank lines at the end of a function (ie, right before a line like '}' + if IsBlankLine(line): + elided = clean_lines.elided + prev_line = elided[linenum - 1] + prevbrace = prev_line.rfind('{') + # TODO(unknown): Don't complain if line before blank line, and line after, + # both start with alnums and are indented the same amount. + # This ignores whitespace at the start of a namespace block + # because those are not usually indented. + if (prevbrace != -1 and prev_line[prevbrace:].find('}') == -1 + and prev_line[:prevbrace].find('namespace') == -1): + # OK, we have a blank line at the start of a code block. Before we + # complain, we check if it is an exception to the rule: The previous + # non-empty line has the paramters of a function header that are indented + # 4 spaces (because they did not fit in a 80 column line when placed on + # the same line as the function name). We also check for the case where + # the previous line is indented 6 spaces, which may happen when the + # initializers of a constructor do not fit into a 80 column line. + exception = False + if Match(r' {6}\w', prev_line): # Initializer list? + # We are looking for the opening column of initializer list, which + # should be indented 4 spaces to cause 6 space indentation afterwards. + search_position = linenum-2 + while (search_position >= 0 + and Match(r' {6}\w', elided[search_position])): + search_position -= 1 + exception = (search_position >= 0 + and elided[search_position][:5] == ' :') + else: + # Search for the function arguments or an initializer list. We use a + # simple heuristic here: If the line is indented 4 spaces; and we have a + # closing paren, without the opening paren, followed by an opening brace + # or colon (for initializer lists) we assume that it is the last line of + # a function header. If we have a colon indented 4 spaces, it is an + # initializer list. + exception = (Match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)', + prev_line) + or Match(r' {4}:', prev_line)) + + if not exception: + error(filename, linenum, 'whitespace/blank_line', 2, + 'Blank line at the start of a code block. Is this needed?') + # This doesn't ignore whitespace at the end of a namespace block + # because that is too hard without pairing open/close braces; + # however, a special exception is made for namespace closing + # brackets which have a comment containing "namespace". + # + # Also, ignore blank lines at the end of a block in a long if-else + # chain, like this: + # if (condition1) { + # // Something followed by a blank line + # + # } else if (condition2) { + # // Something else + # } + if linenum + 1 < clean_lines.NumLines(): + next_line = raw[linenum + 1] + if (next_line + and Match(r'\s*}', next_line) + and next_line.find('namespace') == -1 + and next_line.find('} else ') == -1): + error(filename, linenum, 'whitespace/blank_line', 3, + 'Blank line at the end of a code block. Is this needed?') + + # Next, we complain if there's a comment too near the text + commentpos = line.find('//') + if commentpos != -1: + # Check if the // may be in quotes. If so, ignore it + if (line.count('"', 0, commentpos) - + line.count('\\"', 0, commentpos)) % 2 == 0: # not in quotes + # Allow one space for new scopes, two spaces otherwise: + if (not Match(r'^\s*{ //', line) and + ((commentpos >= 1 and + line[commentpos-1] not in string.whitespace) or + (commentpos >= 2 and + line[commentpos-2] not in string.whitespace))): + error(filename, linenum, 'whitespace/comments', 2, + 'At least two spaces is best between code and comments') + # There should always be a space between the // and the comment + commentend = commentpos + 2 + if commentend < len(line) and not line[commentend] == ' ': + # but some lines are exceptions -- e.g. if they're big + # comment delimiters like: + # //---------------------------------------------------------- + match = Search(r'[=/-]{4,}\s*$', line[commentend:]) + if not match: + error(filename, linenum, 'whitespace/comments', 4, + 'Should have a space between // and comment') + CheckComment(line[commentpos:], filename, linenum, error) + + line = clean_lines.elided[linenum] # get rid of comments and strings + + # Don't try to do spacing checks for operator methods + line = re.sub(r'operator(==|!=|<|<<|<=|>=|>>|>)\(', 'operator\(', line) + + # We allow no-spaces around = within an if: "if ( (a=Foo()) == 0 )". + # Otherwise not. Note we only check for non-spaces on *both* sides; + # sometimes people put non-spaces on one side when aligning ='s among + # many lines (not that this is behavior that I approve of...) + if Search(r'[\w.]=[\w.]', line) and not Search(r'\b(if|while) ', line): + error(filename, linenum, 'whitespace/operators', 4, + 'Missing spaces around =') + + # It's ok not to have spaces around binary operators like + - * /, but if + # there's too little whitespace, we get concerned. It's hard to tell, + # though, so we punt on this one for now. TODO. + + # You should always have whitespace around binary operators. + # Alas, we can't test < or > because they're legitimately used sans spaces + # (a->b, vector a). The only time we can tell is a < with no >, and + # only if it's not template params list spilling into the next line. + match = Search(r'[^<>=!\s](==|!=|<=|>=)[^<>=!\s]', line) + if not match: + # Note that while it seems that the '<[^<]*' term in the following + # regexp could be simplified to '<.*', which would indeed match + # the same class of strings, the [^<] means that searching for the + # regexp takes linear rather than quadratic time. + if not Search(r'<[^<]*,\s*$', line): # template params spill + match = Search(r'[^<>=!\s](<)[^<>=!\s]([^>]|->)*$', line) + if match: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around %s' % match.group(1)) + # We allow no-spaces around << and >> when used like this: 10<<20, but + # not otherwise (particularly, not when used as streams) + match = Search(r'[^0-9\s](<<|>>)[^0-9\s]', line) + if match: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around %s' % match.group(1)) + + # There shouldn't be space around unary operators + match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line) + if match: + error(filename, linenum, 'whitespace/operators', 4, + 'Extra space for operator %s' % match.group(1)) + + # A pet peeve of mine: no spaces after an if, while, switch, or for + match = Search(r' (if\(|for\(|while\(|switch\()', line) + if match: + error(filename, linenum, 'whitespace/parens', 5, + 'Missing space before ( in %s' % match.group(1)) + + # For if/for/while/switch, the left and right parens should be + # consistent about how many spaces are inside the parens, and + # there should either be zero or one spaces inside the parens. + # We don't want: "if ( foo)" or "if ( foo )". + # Exception: "for ( ; foo; bar)" is allowed. + match = Search(r'\b(if|for|while|switch)\s*' + r'\(([ ]*)(.).*[^ ]+([ ]*)\)\s*{\s*$', + line) + if match: + if len(match.group(2)) != len(match.group(4)): + if not (match.group(3) == ';' and + len(match.group(2)) == 1 + len(match.group(4))): + error(filename, linenum, 'whitespace/parens', 5, + 'Mismatching spaces inside () in %s' % match.group(1)) + if not len(match.group(2)) in [0, 1]: + error(filename, linenum, 'whitespace/parens', 5, + 'Should have zero or one spaces inside ( and ) in %s' % + match.group(1)) + + # You should always have a space after a comma (either as fn arg or operator) + if Search(r',[^\s]', line): + error(filename, linenum, 'whitespace/comma', 3, + 'Missing space after ,') + + # Next we will look for issues with function calls. + CheckSpacingForFunctionCall(filename, line, linenum, error) + + # Except after an opening paren, you should have spaces before your braces. + # And since you should never have braces at the beginning of a line, this is + # an easy test. + if Search(r'[^ (]{', line): + error(filename, linenum, 'whitespace/braces', 5, + 'Missing space before {') + + # Make sure '} else {' has spaces. + if Search(r'}else', line): + error(filename, linenum, 'whitespace/braces', 5, + 'Missing space before else') + + # You shouldn't have spaces before your brackets, except maybe after + # 'delete []' or 'new char * []'. + if Search(r'\w\s+\[', line) and not Search(r'delete\s+\[', line): + error(filename, linenum, 'whitespace/braces', 5, + 'Extra space before [') + + # You shouldn't have a space before a semicolon at the end of the line. + # There's a special case for "for" since the style guide allows space before + # the semicolon there. + if Search(r':\s*;\s*$', line): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Semicolon defining empty statement. Use { } instead.') + elif Search(r'^\s*;\s*$', line): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Line contains only semicolon. If this should be an empty statement, ' + 'use { } instead.') + elif (Search(r'\s+;\s*$', line) and + not Search(r'\bfor\b', line)): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Extra space before last semicolon. If this should be an empty ' + 'statement, use { } instead.') + + +def GetPreviousNonBlankLine(clean_lines, linenum): + """Return the most recent non-blank line and its line number. + + Args: + clean_lines: A CleansedLines instance containing the file contents. + linenum: The number of the line to check. + + Returns: + A tuple with two elements. The first element is the contents of the last + non-blank line before the current line, or the empty string if this is the + first non-blank line. The second is the line number of that line, or -1 + if this is the first non-blank line. + """ + + prevlinenum = linenum - 1 + while prevlinenum >= 0: + prevline = clean_lines.elided[prevlinenum] + if not IsBlankLine(prevline): # if not a blank line... + return (prevline, prevlinenum) + prevlinenum -= 1 + return ('', -1) + + +def CheckBraces(filename, clean_lines, linenum, error): + """Looks for misplaced braces (e.g. at the end of line). + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + line = clean_lines.elided[linenum] # get rid of comments and strings + + if Match(r'\s*{\s*$', line): + # We allow an open brace to start a line in the case where someone + # is using braces in a block to explicitly create a new scope, + # which is commonly used to control the lifetime of + # stack-allocated variables. We don't detect this perfectly: we + # just don't complain if the last non-whitespace character on the + # previous non-blank line is ';', ':', '{', or '}'. + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] + if not Search(r'[;:}{]\s*$', prevline): + error(filename, linenum, 'whitespace/braces', 4, + '{ should almost always be at the end of the previous line') + + # An else clause should be on the same line as the preceding closing brace. + if Match(r'\s*else\s*', line): + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] + if Match(r'\s*}\s*$', prevline): + error(filename, linenum, 'whitespace/newline', 4, + 'An else should appear on the same line as the preceding }') + + # If braces come on one side of an else, they should be on both. + # However, we have to worry about "else if" that spans multiple lines! + if Search(r'}\s*else[^{]*$', line) or Match(r'[^}]*else\s*{', line): + if Search(r'}\s*else if([^{]*)$', line): # could be multi-line if + # find the ( after the if + pos = line.find('else if') + pos = line.find('(', pos) + if pos > 0: + (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos) + if endline[endpos:].find('{') == -1: # must be brace after if + error(filename, linenum, 'readability/braces', 5, + 'If an else has a brace on one side, it should have it on both') + else: # common case: else not followed by a multi-line if + error(filename, linenum, 'readability/braces', 5, + 'If an else has a brace on one side, it should have it on both') + + # Likewise, an else should never have the else clause on the same line + if Search(r'\belse [^\s{]', line) and not Search(r'\belse if\b', line): + error(filename, linenum, 'whitespace/newline', 4, + 'Else clause should never be on same line as else (use 2 lines)') + + # In the same way, a do/while should never be on one line + if Match(r'\s*do [^\s{]', line): + error(filename, linenum, 'whitespace/newline', 4, + 'do/while clauses should not be on a single line') + + # Braces shouldn't be followed by a ; unless they're defining a struct + # or initializing an array. + # We can't tell in general, but we can for some common cases. + prevlinenum = linenum + while True: + (prevline, prevlinenum) = GetPreviousNonBlankLine(clean_lines, prevlinenum) + if Match(r'\s+{.*}\s*;', line) and not prevline.count(';'): + line = prevline + line + else: + break + if (Search(r'{.*}\s*;', line) and + line.count('{') == line.count('}') and + not Search(r'struct|class|enum|\s*=\s*{', line)): + error(filename, linenum, 'readability/braces', 4, + "You don't need a ; after a }") + + +def ReplaceableCheck(operator, macro, line): + """Determine whether a basic CHECK can be replaced with a more specific one. + + For example suggest using CHECK_EQ instead of CHECK(a == b) and + similarly for CHECK_GE, CHECK_GT, CHECK_LE, CHECK_LT, CHECK_NE. + + Args: + operator: The C++ operator used in the CHECK. + macro: The CHECK or EXPECT macro being called. + line: The current source line. + + Returns: + True if the CHECK can be replaced with a more specific one. + """ + + # This matches decimal and hex integers, strings, and chars (in that order). + match_constant = r'([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')' + + # Expression to match two sides of the operator with something that + # looks like a literal, since CHECK(x == iterator) won't compile. + # This means we can't catch all the cases where a more specific + # CHECK is possible, but it's less annoying than dealing with + # extraneous warnings. + match_this = (r'\s*' + macro + r'\((\s*' + + match_constant + r'\s*' + operator + r'[^<>].*|' + r'.*[^<>]' + operator + r'\s*' + match_constant + + r'\s*\))') + + # Don't complain about CHECK(x == NULL) or similar because + # CHECK_EQ(x, NULL) won't compile (requires a cast). + # Also, don't complain about more complex boolean expressions + # involving && or || such as CHECK(a == b || c == d). + return Match(match_this, line) and not Search(r'NULL|&&|\|\|', line) + + +def CheckCheck(filename, clean_lines, linenum, error): + """Checks the use of CHECK and EXPECT macros. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + error: The function to call with any errors found. + """ + + # Decide the set of replacement macros that should be suggested + raw_lines = clean_lines.raw_lines + current_macro = '' + for macro in _CHECK_MACROS: + if raw_lines[linenum].find(macro) >= 0: + current_macro = macro + break + if not current_macro: + # Don't waste time here if line doesn't contain 'CHECK' or 'EXPECT' + return + + line = clean_lines.elided[linenum] # get rid of comments and strings + + # Encourage replacing plain CHECKs with CHECK_EQ/CHECK_NE/etc. + for operator in ['==', '!=', '>=', '>', '<=', '<']: + if ReplaceableCheck(operator, current_macro, line): + error(filename, linenum, 'readability/check', 2, + 'Consider using %s instead of %s(a %s b)' % ( + _CHECK_REPLACEMENT[current_macro][operator], + current_macro, operator)) + break + + +def GetLineWidth(line): + """Determines the width of the line in column positions. + + Args: + line: A string, which may be a Unicode string. + + Returns: + The width of the line in column positions, accounting for Unicode + combining characters and wide characters. + """ + if isinstance(line, unicode): + width = 0 + for c in unicodedata.normalize('NFC', line): + if unicodedata.east_asian_width(c) in ('W', 'F'): + width += 2 + elif not unicodedata.combining(c): + width += 1 + return width + else: + return len(line) + + +def CheckStyle(filename, clean_lines, linenum, file_extension, error): + """Checks rules from the 'C++ style rules' section of cppguide.html. + + Most of these rules are hard to test (naming, comment style), but we + do what we can. In particular we check for 2-space indents, line lengths, + tab usage, spaces inside code, etc. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + file_extension: The extension (without the dot) of the filename. + error: The function to call with any errors found. + """ + + raw_lines = clean_lines.raw_lines + line = raw_lines[linenum] + + if line.find('\t') != -1: + error(filename, linenum, 'whitespace/tab', 1, + 'Tab found; better to use spaces') + + # One or three blank spaces at the beginning of the line is weird; it's + # hard to reconcile that with 2-space indents. + # NOTE: here are the conditions rob pike used for his tests. Mine aren't + # as sophisticated, but it may be worth becoming so: RLENGTH==initial_spaces + # if(RLENGTH > 20) complain = 0; + # if(match($0, " +(error|private|public|protected):")) complain = 0; + # if(match(prev, "&& *$")) complain = 0; + # if(match(prev, "\\|\\| *$")) complain = 0; + # if(match(prev, "[\",=><] *$")) complain = 0; + # if(match($0, " <<")) complain = 0; + # if(match(prev, " +for \\(")) complain = 0; + # if(prevodd && match(prevprev, " +for \\(")) complain = 0; + initial_spaces = 0 + cleansed_line = clean_lines.elided[linenum] + while initial_spaces < len(line) and line[initial_spaces] == ' ': + initial_spaces += 1 + if line and line[-1].isspace(): + error(filename, linenum, 'whitespace/end_of_line', 4, + 'Line ends in whitespace. Consider deleting these extra spaces.') + # There are certain situations we allow one space, notably for labels + elif ((initial_spaces == 1 or initial_spaces == 3) and + not Match(r'\s*\w+\s*:\s*$', cleansed_line)): + error(filename, linenum, 'whitespace/indent', 3, + 'Weird number of spaces at line-start. ' + 'Are you using a 2-space indent?') + # Labels should always be indented at least one space. + elif not initial_spaces and line[:2] != '//' and Search(r'[^:]:\s*$', + line): + error(filename, linenum, 'whitespace/labels', 4, + 'Labels should always be indented at least one space. ' + 'If this is a member-initializer list in a constructor, ' + 'the colon should be on the line after the definition header.') + + # Check if the line is a header guard. + is_header_guard = False + if file_extension == 'h': + cppvar = GetHeaderGuardCPPVariable(filename) + if (line.startswith('#ifndef %s' % cppvar) or + line.startswith('#define %s' % cppvar) or + line.startswith('#endif // %s' % cppvar)): + is_header_guard = True + # #include lines and header guards can be long, since there's no clean way to + # split them. + if not line.startswith('#include') and not is_header_guard: + line_width = GetLineWidth(line) + if line_width > 100: + error(filename, linenum, 'whitespace/line_length', 4, + 'Lines should very rarely be longer than 100 characters') + elif line_width > 80: + error(filename, linenum, 'whitespace/line_length', 2, + 'Lines should be <= 80 characters long') + + if (cleansed_line.count(';') > 1 and + # for loops are allowed two ;'s (and may run over two lines). + cleansed_line.find('for') == -1 and + (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or + GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and + # It's ok to have many commands in a switch case that fits in 1 line + not ((cleansed_line.find('case ') != -1 or + cleansed_line.find('default:') != -1) and + cleansed_line.find('break;') != -1)): + error(filename, linenum, 'whitespace/newline', 4, + 'More than one command on the same line') + + # Some more style checks + CheckBraces(filename, clean_lines, linenum, error) + CheckSpacing(filename, clean_lines, linenum, error) + CheckCheck(filename, clean_lines, linenum, error) + + +_RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"') +_RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$') +# Matches the first component of a filename delimited by -s and _s. That is: +# _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo.cc').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo-bar_baz.cc').group(0) == 'foo' +# _RE_FIRST_COMPONENT.match('foo_bar-baz.cc').group(0) == 'foo' +_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+') + + +def _DropCommonSuffixes(filename): + """Drops common suffixes like _test.cc or -inl.h from filename. + + For example: + >>> _DropCommonSuffixes('foo/foo-inl.h') + 'foo/foo' + >>> _DropCommonSuffixes('foo/bar/foo.cc') + 'foo/bar/foo' + >>> _DropCommonSuffixes('foo/foo_internal.h') + 'foo/foo' + >>> _DropCommonSuffixes('foo/foo_unusualinternal.h') + 'foo/foo_unusualinternal' + + Args: + filename: The input filename. + + Returns: + The filename with the common suffix removed. + """ + for suffix in ('test.cc', 'regtest.cc', 'unittest.cc', + 'inl.h', 'impl.h', 'internal.h'): + if (filename.endswith(suffix) and len(filename) > len(suffix) and + filename[-len(suffix) - 1] in ('-', '_')): + return filename[:-len(suffix) - 1] + return os.path.splitext(filename)[0] + + +def _IsTestFilename(filename): + """Determines if the given filename has a suffix that identifies it as a test. + + Args: + filename: The input filename. + + Returns: + True if 'filename' looks like a test, False otherwise. + """ + if (filename.endswith('_test.cc') or + filename.endswith('_unittest.cc') or + filename.endswith('_regtest.cc')): + return True + else: + return False + + +def _ClassifyInclude(fileinfo, include, is_system): + """Figures out what kind of header 'include' is. + + Args: + fileinfo: The current file cpplint is running over. A FileInfo instance. + include: The path to a #included file. + is_system: True if the #include used <> rather than "". + + Returns: + One of the _XXX_HEADER constants. + + For example: + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True) + _C_SYS_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True) + _CPP_SYS_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False) + _LIKELY_MY_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'), + ... 'bar/foo_other_ext.h', False) + _POSSIBLE_MY_HEADER + >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False) + _OTHER_HEADER + """ + # This is a list of all standard c++ header files, except + # those already checked for above. + is_stl_h = include in _STL_HEADERS + is_cpp_h = is_stl_h or include in _CPP_HEADERS + + if is_system: + if is_cpp_h: + return _CPP_SYS_HEADER + else: + return _C_SYS_HEADER + + # If the target file and the include we're checking share a + # basename when we drop common extensions, and the include + # lives in . , then it's likely to be owned by the target file. + target_dir, target_base = ( + os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName()))) + include_dir, include_base = os.path.split(_DropCommonSuffixes(include)) + if target_base == include_base and ( + include_dir == target_dir or + include_dir == os.path.normpath(target_dir + '/../public')): + return _LIKELY_MY_HEADER + + # If the target and include share some initial basename + # component, it's possible the target is implementing the + # include, so it's allowed to be first, but we'll never + # complain if it's not there. + target_first_component = _RE_FIRST_COMPONENT.match(target_base) + include_first_component = _RE_FIRST_COMPONENT.match(include_base) + if (target_first_component and include_first_component and + target_first_component.group(0) == + include_first_component.group(0)): + return _POSSIBLE_MY_HEADER + + return _OTHER_HEADER + + +def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state, + error): + """Checks rules from the 'C++ language rules' section of cppguide.html. + + Some of these rules are hard to test (function overloading, using + uint32 inappropriately), but we do the best we can. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + linenum: The number of the line to check. + file_extension: The extension (without the dot) of the filename. + include_state: An _IncludeState instance in which the headers are inserted. + error: The function to call with any errors found. + """ + fileinfo = FileInfo(filename) + + # get rid of comments + comment_elided_line = clean_lines.lines[linenum] + + # "include" should use the new style "foo/bar.h" instead of just "bar.h" + if _RE_PATTERN_INCLUDE_NEW_STYLE.search(comment_elided_line): + error(filename, linenum, 'build/include', 4, + 'Include the directory when naming .h files') + + # we shouldn't include a file more than once. actually, there are a + # handful of instances where doing so is okay, but in general it's + # not. + match = _RE_PATTERN_INCLUDE.search(comment_elided_line) + if match: + include = match.group(2) + is_system = (match.group(1) == '<') + if include in include_state: + error(filename, linenum, 'build/include', 4, + '"%s" already included at %s:%s' % + (include, filename, include_state[include])) + else: + include_state[include] = linenum + + # We want to ensure that headers appear in the right order: + # 1) for foo.cc, foo.h (preferred location) + # 2) c system files + # 3) cpp system files + # 4) for foo.cc, foo.h (deprecated location) + # 5) other google headers + # + # We classify each include statement as one of those 5 types + # using a number of techniques. The include_state object keeps + # track of the highest type seen, and complains if we see a + # lower type after that. + error_message = include_state.CheckNextIncludeOrder( + _ClassifyInclude(fileinfo, include, is_system)) + if error_message: + error(filename, linenum, 'build/include_order', 4, + '%s. Should be: %s.h, c system, c++ system, other.' % + (error_message, fileinfo.BaseName())) + + # If the line is empty or consists of entirely a comment, no need to + # check it. + line = clean_lines.elided[linenum] + if not line: + return + + # Create an extended_line, which is the concatenation of the current and + # next lines, for more effective checking of code that may span more than one + # line. + if linenum + 1 < clean_lines.NumLines(): + extended_line = line + clean_lines.elided[linenum + 1] + else: + extended_line = line + + # Make Windows paths like Unix. + fullname = os.path.abspath(filename).replace('\\', '/') + + # TODO(unknown): figure out if they're using default arguments in fn proto. + + # Look for any of the stream classes that are part of standard C++. + match = _RE_PATTERN_INCLUDE.match(line) + if match: + include = match.group(2) + if Match(r'(f|ind|io|i|o|parse|pf|stdio|str|)?stream$', include): + # Many unit tests use cout, so we exempt them. + if not _IsTestFilename(filename): + error(filename, linenum, 'readability/streams', 3, + 'Streams are highly discouraged.') + + # Check for non-const references in functions. This is tricky because & + # is also used to take the address of something. We allow <> for templates, + # (ignoring whatever is between the braces) and : for classes. + # These are complicated re's. They try to capture the following: + # paren (for fn-prototype start), typename, &, varname. For the const + # version, we're willing for const to be before typename or after + # Don't check the implemention on same line. + fnline = line.split('{', 1)[0] + if (len(re.findall(r'\([^()]*\b(?:[\w:]|<[^()]*>)+(\s?&|&\s?)\w+', fnline)) > + len(re.findall(r'\([^()]*\bconst\s+(?:typename\s+)?(?:struct\s+)?' + r'(?:[\w:]|<[^()]*>)+(\s?&|&\s?)\w+', fnline)) + + len(re.findall(r'\([^()]*\b(?:[\w:]|<[^()]*>)+\s+const(\s?&|&\s?)[\w]+', + fnline))): + + # We allow non-const references in a few standard places, like functions + # called "swap()" or iostream operators like "<<" or ">>". + if not Search( + r'(swap|Swap|operator[<>][<>])\s*\(\s*(?:[\w:]|<.*>)+\s*&', + fnline): + error(filename, linenum, 'runtime/references', 2, + 'Is this a non-const reference? ' + 'If so, make const or use a pointer.') + + # Check to see if they're using an conversion function cast. + # I just try to capture the most common basic types, though there are more. + # Parameterless conversion functions, such as bool(), are allowed as they are + # probably a member operator declaration or default constructor. + match = Search( + r'\b(int|float|double|bool|char|int32|uint32|int64|uint64)\([^)]', line) + if match: + # gMock methods are defined using some variant of MOCK_METHODx(name, type) + # where type may be float(), int(string), etc. Without context they are + # virtually indistinguishable from int(x) casts. + if not Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line): + error(filename, linenum, 'readability/casting', 4, + 'Using deprecated casting style. ' + 'Use static_cast<%s>(...) instead' % + match.group(1)) + + CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum], + 'static_cast', + r'\((int|float|double|bool|char|u?int(16|32|64))\)', + error) + # This doesn't catch all cases. Consider (const char * const)"hello". + CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum], + 'reinterpret_cast', r'\((\w+\s?\*+\s?)\)', error) + + # In addition, we look for people taking the address of a cast. This + # is dangerous -- casts can assign to temporaries, so the pointer doesn't + # point where you think. + if Search( + r'(&\([^)]+\)[\w(])|(&(static|dynamic|reinterpret)_cast\b)', line): + error(filename, linenum, 'runtime/casting', 4, + ('Are you taking an address of a cast? ' + 'This is dangerous: could be a temp var. ' + 'Take the address before doing the cast, rather than after')) + + # Check for people declaring static/global STL strings at the top level. + # This is dangerous because the C++ language does not guarantee that + # globals with constructors are initialized before the first access. + match = Match( + r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\b(.*)', + line) + # Make sure it's not a function. + # Function template specialization looks like: "string foo(...". + # Class template definitions look like: "string Foo::Method(...". + if match and not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)?\s*\(([^"]|$)', + match.group(3)): + error(filename, linenum, 'runtime/string', 4, + 'For a static/global string constant, use a C style string instead: ' + '"%schar %s[]".' % + (match.group(1), match.group(2))) + + # Check that we're not using RTTI outside of testing code. + if Search(r'\bdynamic_cast<', line) and not _IsTestFilename(filename): + error(filename, linenum, 'runtime/rtti', 5, + 'Do not use dynamic_cast<>. If you need to cast within a class ' + "hierarchy, use static_cast<> to upcast. Google doesn't support " + 'RTTI.') + + if Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line): + error(filename, linenum, 'runtime/init', 4, + 'You seem to be initializing a member variable with itself.') + + if file_extension == 'h': + # TODO(unknown): check that 1-arg constructors are explicit. + # How to tell it's a constructor? + # (handled in CheckForNonStandardConstructs for now) + # TODO(unknown): check that classes have DISALLOW_EVIL_CONSTRUCTORS + # (level 1 error) + pass + + # Check if people are using the verboten C basic types. The only exception + # we regularly allow is "unsigned short port" for port. + if Search(r'\bshort port\b', line): + if not Search(r'\bunsigned short port\b', line): + error(filename, linenum, 'runtime/int', 4, + 'Use "unsigned short" for ports, not "short"') + else: + match = Search(r'\b(short|long(?! +double)|long long)\b', line) + if match: + error(filename, linenum, 'runtime/int', 4, + 'Use int16/int64/etc, rather than the C type %s' % match.group(1)) + + # When snprintf is used, the second argument shouldn't be a literal. + match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line) + if match: + error(filename, linenum, 'runtime/printf', 3, + 'If you can, use sizeof(%s) instead of %s as the 2nd arg ' + 'to snprintf.' % (match.group(1), match.group(2))) + + # Check if some verboten C functions are being used. + if Search(r'\bsprintf\b', line): + error(filename, linenum, 'runtime/printf', 5, + 'Never use sprintf. Use snprintf instead.') + match = Search(r'\b(strcpy|strcat)\b', line) + if match: + error(filename, linenum, 'runtime/printf', 4, + 'Almost always, snprintf is better than %s' % match.group(1)) + + if Search(r'\bsscanf\b', line): + error(filename, linenum, 'runtime/printf', 1, + 'sscanf can be ok, but is slow and can overflow buffers.') + + # Check for suspicious usage of "if" like + # } if (a == b) { + if Search(r'\}\s*if\s*\(', line): + error(filename, linenum, 'readability/braces', 4, + 'Did you mean "else if"? If not, start a new line for "if".') + + # Check for potential format string bugs like printf(foo). + # We constrain the pattern not to pick things like DocidForPrintf(foo). + # Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str()) + match = re.search(r'\b((?:string)?printf)\s*\(([\w.\->()]+)\)', line, re.I) + if match: + error(filename, linenum, 'runtime/printf', 4, + 'Potential format string bug. Do %s("%%s", %s) instead.' + % (match.group(1), match.group(2))) + + # Check for potential memset bugs like memset(buf, sizeof(buf), 0). + match = Search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line) + if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)): + error(filename, linenum, 'runtime/memset', 4, + 'Did you mean "memset(%s, 0, %s)"?' + % (match.group(1), match.group(2))) + + if Search(r'\busing namespace\b', line): + error(filename, linenum, 'build/namespaces', 5, + 'Do not use namespace using-directives. ' + 'Use using-declarations instead.') + + # Detect variable-length arrays. + match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line) + if (match and match.group(2) != 'return' and match.group(2) != 'delete' and + match.group(3).find(']') == -1): + # Split the size using space and arithmetic operators as delimiters. + # If any of the resulting tokens are not compile time constants then + # report the error. + tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', match.group(3)) + is_const = True + skip_next = False + for tok in tokens: + if skip_next: + skip_next = False + continue + + if Search(r'sizeof\(.+\)', tok): continue + if Search(r'arraysize\(\w+\)', tok): continue + + tok = tok.lstrip('(') + tok = tok.rstrip(')') + if not tok: continue + if Match(r'\d+', tok): continue + if Match(r'0[xX][0-9a-fA-F]+', tok): continue + if Match(r'k[A-Z0-9]\w*', tok): continue + if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue + if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue + # A catch all for tricky sizeof cases, including 'sizeof expression', + # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)' + # requires skipping the next token becasue we split on ' ' and '*'. + if tok.startswith('sizeof'): + skip_next = True + continue + is_const = False + break + if not is_const: + error(filename, linenum, 'runtime/arrays', 1, + 'Do not use variable-length arrays. Use an appropriately named ' + "('k' followed by CamelCase) compile-time constant for the size.") + + # If DISALLOW_EVIL_CONSTRUCTORS, DISALLOW_COPY_AND_ASSIGN, or + # DISALLOW_IMPLICIT_CONSTRUCTORS is present, then it should be the last thing + # in the class declaration. + match = Match( + (r'\s*' + r'(DISALLOW_(EVIL_CONSTRUCTORS|COPY_AND_ASSIGN|IMPLICIT_CONSTRUCTORS))' + r'\(.*\);$'), + line) + if match and linenum + 1 < clean_lines.NumLines(): + next_line = clean_lines.elided[linenum + 1] + if not Search(r'^\s*};', next_line): + error(filename, linenum, 'readability/constructors', 3, + match.group(1) + ' should be the last thing in the class') + + # Check for use of unnamed namespaces in header files. Registration + # macros are typically OK, so we allow use of "namespace {" on lines + # that end with backslashes. + if (file_extension == 'h' + and Search(r'\bnamespace\s*{', line) + and line[-1] != '\\'): + error(filename, linenum, 'build/namespaces', 4, + 'Do not use unnamed namespaces in header files. See ' + 'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces' + ' for more information.') + + +def CheckCStyleCast(filename, linenum, line, raw_line, cast_type, pattern, + error): + """Checks for a C-style cast by looking for the pattern. + + This also handles sizeof(type) warnings, due to similarity of content. + + Args: + filename: The name of the current file. + linenum: The number of the line to check. + line: The line of code to check. + raw_line: The raw line of code to check, with comments. + cast_type: The string for the C++ cast to recommend. This is either + reinterpret_cast or static_cast, depending. + pattern: The regular expression used to find C-style casts. + error: The function to call with any errors found. + """ + match = Search(pattern, line) + if not match: + return + + # e.g., sizeof(int) + sizeof_match = Match(r'.*sizeof\s*$', line[0:match.start(1) - 1]) + if sizeof_match: + error(filename, linenum, 'runtime/sizeof', 1, + 'Using sizeof(type). Use sizeof(varname) instead if possible') + return + + remainder = line[match.end(0):] + + # The close paren is for function pointers as arguments to a function. + # eg, void foo(void (*bar)(int)); + # The semicolon check is a more basic function check; also possibly a + # function pointer typedef. + # eg, void foo(int); or void foo(int) const; + # The equals check is for function pointer assignment. + # eg, void *(*foo)(int) = ... + # + # Right now, this will only catch cases where there's a single argument, and + # it's unnamed. It should probably be expanded to check for multiple + # arguments with some unnamed. + function_match = Match(r'\s*(\)|=|(const)?\s*(;|\{|throw\(\)))', remainder) + if function_match: + if (not function_match.group(3) or + function_match.group(3) == ';' or + raw_line.find('/*') < 0): + error(filename, linenum, 'readability/function', 3, + 'All parameters should be named in a function') + return + + # At this point, all that should be left is actual casts. + error(filename, linenum, 'readability/casting', 4, + 'Using C-style cast. Use %s<%s>(...) instead' % + (cast_type, match.group(1))) + + +_HEADERS_CONTAINING_TEMPLATES = ( + ('', ('deque',)), + ('', ('unary_function', 'binary_function', + 'plus', 'minus', 'multiplies', 'divides', 'modulus', + 'negate', + 'equal_to', 'not_equal_to', 'greater', 'less', + 'greater_equal', 'less_equal', + 'logical_and', 'logical_or', 'logical_not', + 'unary_negate', 'not1', 'binary_negate', 'not2', + 'bind1st', 'bind2nd', + 'pointer_to_unary_function', + 'pointer_to_binary_function', + 'ptr_fun', + 'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t', + 'mem_fun_ref_t', + 'const_mem_fun_t', 'const_mem_fun1_t', + 'const_mem_fun_ref_t', 'const_mem_fun1_ref_t', + 'mem_fun_ref', + )), + ('', ('numeric_limits',)), + ('', ('list',)), + ('', ('map', 'multimap',)), + ('', ('allocator',)), + ('', ('queue', 'priority_queue',)), + ('', ('set', 'multiset',)), + ('', ('stack',)), + ('', ('char_traits', 'basic_string',)), + ('', ('pair',)), + ('', ('vector',)), + + # gcc extensions. + # Note: std::hash is their hash, ::hash is our hash + ('', ('hash_map', 'hash_multimap',)), + ('', ('hash_set', 'hash_multiset',)), + ('', ('slist',)), + ) + +_HEADERS_ACCEPTED_BUT_NOT_PROMOTED = { + # We can trust with reasonable confidence that map gives us pair<>, too. + 'pair<>': ('map', 'multimap', 'hash_map', 'hash_multimap') +} + +_RE_PATTERN_STRING = re.compile(r'\bstring\b') + +_re_pattern_algorithm_header = [] +for _template in ('copy', 'max', 'min', 'sort', 'swap'): + # Match max(..., ...), max(..., ...), but not foo->max, foo.max or + # type::max(). + _re_pattern_algorithm_header.append( + (re.compile(r'[^>.]\b' + _template + r'(<.*?>)?\([^\)]'), + _template, + '')) + +_re_pattern_templates = [] +for _header, _templates in _HEADERS_CONTAINING_TEMPLATES: + for _template in _templates: + _re_pattern_templates.append( + (re.compile(r'(\<|\b)' + _template + r'\s*\<'), + _template + '<>', + _header)) + + +def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error): + """Reports for missing stl includes. + + This function will output warnings to make sure you are including the headers + necessary for the stl containers and functions that you use. We only give one + reason to include a header. For example, if you use both equal_to<> and + less<> in a .h file, only one (the latter in the file) of these will be + reported as a reason to include the . + + We only check headers. We do not check inside cc-files. .cc files should be + able to depend on their respective header files for includes. However, there + is no simple way of producing this logic here. + + Args: + filename: The name of the current file. + clean_lines: A CleansedLines instance containing the file. + include_state: An _IncludeState instance. + error: The function to call with any errors found. + """ + if filename.endswith('.cc'): + return + + required = {} # A map of header name to linenumber and the template entity. + # Example of required: { '': (1219, 'less<>') } + + for linenum in xrange(clean_lines.NumLines()): + line = clean_lines.elided[linenum] + if not line or line[0] == '#': + continue + + # String is special -- it is a non-templatized type in STL. + if _RE_PATTERN_STRING.search(line): + required[''] = (linenum, 'string') + + for pattern, template, header in _re_pattern_algorithm_header: + if pattern.search(line): + required[header] = (linenum, template) + + # The following function is just a speed up, no semantics are changed. + if not '<' in line: # Reduces the cpu time usage by skipping lines. + continue + + for pattern, template, header in _re_pattern_templates: + if pattern.search(line): + required[header] = (linenum, template) + + # All the lines have been processed, report the errors found. + for required_header_unstripped in required: + template = required[required_header_unstripped][1] + if template in _HEADERS_ACCEPTED_BUT_NOT_PROMOTED: + headers = _HEADERS_ACCEPTED_BUT_NOT_PROMOTED[template] + if [True for header in headers if header in include_state]: + continue + if required_header_unstripped.strip('<>"') not in include_state: + error(filename, required[required_header_unstripped][0], + 'build/include_what_you_use', 4, + 'Add #include ' + required_header_unstripped + ' for ' + template) + + +def ProcessLine(filename, file_extension, + clean_lines, line, include_state, function_state, + class_state, error): + """Processes a single line in the file. + + Args: + filename: Filename of the file that is being processed. + file_extension: The extension (dot not included) of the file. + clean_lines: An array of strings, each representing a line of the file, + with comments stripped. + line: Number of line being processed. + include_state: An _IncludeState instance in which the headers are inserted. + function_state: A _FunctionState instance which counts function lines, etc. + class_state: A _ClassState instance which maintains information about + the current stack of nested class declarations being parsed. + error: A callable to which errors are reported, which takes 4 arguments: + filename, line number, error level, and message + + """ + raw_lines = clean_lines.raw_lines + CheckForFunctionLengths(filename, clean_lines, line, function_state, error) + if Search(r'\bNOLINT\b', raw_lines[line]): # ignore nolint lines + return + CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error) + CheckStyle(filename, clean_lines, line, file_extension, error) + CheckLanguage(filename, clean_lines, line, file_extension, include_state, + error) + CheckForNonStandardConstructs(filename, clean_lines, line, + class_state, error) + CheckPosixThreading(filename, clean_lines, line, error) + + +def ProcessFileData(filename, file_extension, lines, error): + """Performs lint checks and reports any errors to the given error function. + + Args: + filename: Filename of the file that is being processed. + file_extension: The extension (dot not included) of the file. + lines: An array of strings, each representing a line of the file, with the + last element being empty if the file is termined with a newline. + error: A callable to which errors are reported, which takes 4 arguments: + """ + lines = (['// marker so line numbers and indices both start at 1'] + lines + + ['// marker so line numbers end in a known way']) + + include_state = _IncludeState() + function_state = _FunctionState() + class_state = _ClassState() + + CheckForCopyright(filename, lines, error) + + if file_extension == 'h': + CheckForHeaderGuard(filename, lines, error) + + RemoveMultiLineComments(filename, lines, error) + clean_lines = CleansedLines(lines) + for line in xrange(clean_lines.NumLines()): + ProcessLine(filename, file_extension, clean_lines, line, + include_state, function_state, class_state, error) + class_state.CheckFinished(filename, error) + + CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error) + + # We check here rather than inside ProcessLine so that we see raw + # lines rather than "cleaned" lines. + CheckForUnicodeReplacementCharacters(filename, lines, error) + + CheckForNewlineAtEOF(filename, lines, error) + + +def ProcessFile(filename, vlevel): + """Does google-lint on a single file. + + Args: + filename: The name of the file to parse. + + vlevel: The level of errors to report. Every error of confidence + >= verbose_level will be reported. 0 is a good default. + """ + + _SetVerboseLevel(vlevel) + + try: + # Support the UNIX convention of using "-" for stdin. Note that + # we are not opening the file with universal newline support + # (which codecs doesn't support anyway), so the resulting lines do + # contain trailing '\r' characters if we are reading a file that + # has CRLF endings. + # If after the split a trailing '\r' is present, it is removed + # below. If it is not expected to be present (i.e. os.linesep != + # '\r\n' as in Windows), a warning is issued below if this file + # is processed. + + if filename == '-': + lines = codecs.StreamReaderWriter(sys.stdin, + codecs.getreader('utf8'), + codecs.getwriter('utf8'), + 'replace').read().split('\n') + else: + lines = codecs.open(filename, 'r', 'utf8', 'replace').read().split('\n') + + carriage_return_found = False + # Remove trailing '\r'. + for linenum in range(len(lines)): + if lines[linenum].endswith('\r'): + lines[linenum] = lines[linenum].rstrip('\r') + carriage_return_found = True + + except IOError: + sys.stderr.write( + "Skipping input '%s': Can't open for reading\n" % filename) + return + + # Note, if no dot is found, this will give the entire filename as the ext. + file_extension = filename[filename.rfind('.') + 1:] + + # When reading from stdin, the extension is unknown, so no cpplint tests + # should rely on the extension. + if (filename != '-' and file_extension != 'cc' and file_extension != 'h' + and file_extension != 'cpp'): + sys.stderr.write('Ignoring %s; not a .cc or .h file\n' % filename) + else: + ProcessFileData(filename, file_extension, lines, Error) + if carriage_return_found and os.linesep != '\r\n': + # Use 0 for linenum since outputing only one error for potentially + # several lines. + Error(filename, 0, 'whitespace/newline', 1, + 'One or more unexpected \\r (^M) found;' + 'better to use only a \\n') + + sys.stderr.write('Done processing %s\n' % filename) + + +def PrintUsage(message): + """Prints a brief usage string and exits, optionally with an error message. + + Args: + message: The optional error message. + """ + sys.stderr.write(_USAGE) + if message: + sys.exit('\nFATAL ERROR: ' + message) + else: + sys.exit(1) + + +def PrintCategories(): + """Prints a list of all the error-categories used by error messages. + + These are the categories used to filter messages via --filter. + """ + sys.stderr.write(_ERROR_CATEGORIES) + sys.exit(0) + + +def ParseArguments(args): + """Parses the command line arguments. + + This may set the output format and verbosity level as side-effects. + + Args: + args: The command line arguments: + + Returns: + The list of filenames to lint. + """ + try: + (opts, filenames) = getopt.getopt(args, '', ['help', 'output=', 'verbose=', + 'filter=']) + except getopt.GetoptError: + PrintUsage('Invalid arguments.') + + verbosity = _VerboseLevel() + output_format = _OutputFormat() + filters = '' + + for (opt, val) in opts: + if opt == '--help': + PrintUsage(None) + elif opt == '--output': + if not val in ('emacs', 'vs7'): + PrintUsage('The only allowed output formats are emacs and vs7.') + output_format = val + elif opt == '--verbose': + verbosity = int(val) + elif opt == '--filter': + filters = val + if filters == '': + PrintCategories() + + if not filenames: + PrintUsage('No files were specified.') + + _SetOutputFormat(output_format) + _SetVerboseLevel(verbosity) + _SetFilters(filters) + + return filenames + + +def main(): + filenames = ParseArguments(sys.argv[1:]) + + # Change stderr to write with replacement characters so we don't die + # if we try to print something containing non-ASCII characters. + sys.stderr = codecs.StreamReaderWriter(sys.stderr, + codecs.getreader('utf8'), + codecs.getwriter('utf8'), + 'replace') + + _cpplint_state.ResetErrorCount() + for filename in filenames: + ProcessFile(filename, _cpplint_state.verbose_level) + sys.stderr.write('Total errors found: %d\n' % _cpplint_state.error_count) + sys.exit(_cpplint_state.error_count > 0) + + +if __name__ == '__main__': + main() diff --git a/bin/protoc-gen-pbrpc b/bin/protoc-gen-pbrpc new file mode 100755 index 0000000..75ba193 --- /dev/null +++ b/bin/protoc-gen-pbrpc @@ -0,0 +1,4 @@ +#!/bin/bash +FULLPATH=`readlink -f $0` +BASEDIR=`dirname ${FULLPATH}` +java -cp ${BASEDIR}/../java/pbrpcgen/dist/pbrpcgen.jar:${BASEDIR}/../java/lib/protobuf-java-2.5.0.jar org.xtreemfs.pbrpcgen.RPCSourceGenerator diff --git a/bin/protoc-gen-pbrpccpp b/bin/protoc-gen-pbrpccpp new file mode 100755 index 0000000..44a8aaf --- /dev/null +++ b/bin/protoc-gen-pbrpccpp @@ -0,0 +1,4 @@ +#!/bin/bash +FULLPATH=`readlink -f $0` +BASEDIR=`dirname ${FULLPATH}` +java -cp ${BASEDIR}/../java/pbrpcgen/dist/pbrpcgen.jar:${BASEDIR}/../java/lib/protobuf-java-2.5.0.jar org.xtreemfs.pbrpcgen.RPCCPPSourceGenerator diff --git a/bin/toggle_jcip_annnotations.sh b/bin/toggle_jcip_annnotations.sh new file mode 100755 index 0000000..25b4364 --- /dev/null +++ b/bin/toggle_jcip_annnotations.sh @@ -0,0 +1,78 @@ +#!/bin/bash + +# Copyright (c) 2012 by Michael Berlin, Zuse Institute Berlin +# +# Licensed under the BSD License, see LICENSE file for details. +# +# This file is only used for developers of the Java code. +# It allows to comment and uncomment the JCIP annotations (http://www.jcip.net/). +# +# If JCIP annotations are enabled, the jcip-annotations.jar is required for +# compiling and running the XtreemFS code. However, we do not want to package +# it as part of binary packages. Therefore, this script is used to comment +# the annotations in the code. We do not delete the annotations from the code +# since we want to keep them as documentation - even if currently (Feb 2012) +# there is no tool available to evaluate them. + +function display_usage() { + cat < Comments all JCIP annotations found in .java files in path +-u Uncomments all JCIP annotations found in .java files in path +EOF +} + +if [ -z "$1" ] +then + display_usage + exit 1 +fi + +while getopts ":hc:u:" opt +do + case $opt in + c) + mode="comment" + path="$OPTARG" + ;; + u) + mode="uncomment" + path="$OPTARG" + ;; + h) + display_usage + exit 1 + ;; + \?) + echo "Invalid option: -$OPTARG" >&2 + exit 1 + ;; + :) + echo "Option -$OPTARG requires a path as an argument." >&2 + exit 1 + ;; + esac +done + +if [ -z "$mode" ] +then + echo "Error: Run with -c or -u ." + exit 1 +fi + +if [ ! "$path" ] +then + echo "Error: The given path \"$path\" does not exist." + exit 1 +fi + +comment_prefix="\/\/ JCIP " +if [ "$mode" = "comment" ] +then +# find "$path" -iname "*.java" -exec sed -r -i -e "s/^([^\/][^\/].*@(GuardedBy|Immutable|NotThreadSafe|ThreadSafe).*)$/$comment_prefix\1/" {} \; + find "$path" -iname "*.java" -exec sed -r -i -e "s/^([^\/][^\/].*(@|net\.jcip\.annotations\.)(GuardedBy|Immutable|NotThreadSafe|ThreadSafe).*)$/$comment_prefix\1/" {} \; +else + find "$path" -iname "*.java" -exec sed -r -i -e "s/^$comment_prefix([^\/][^\/].*(@|net\.jcip\.annotations\.)(GuardedBy|Immutable|NotThreadSafe|ThreadSafe).*)$/\1/" {} \; +fi \ No newline at end of file diff --git a/bin/umount.xtreemfs b/bin/umount.xtreemfs new file mode 100755 index 0000000..b0f8061 --- /dev/null +++ b/bin/umount.xtreemfs @@ -0,0 +1,12 @@ +#!/bin/bash +# a simple wrapper around fusermount -u, now passes all args to fusermount + +if [ "x$1" == "x" -o "$1" == "--help" -o "$1" == "-h" ] +then + echo "usage: umount.xtreemfs " + echo "" + exit 1 +fi + +fusermount -u $@ +exit $? diff --git a/bin/xtfs_benchmark b/bin/xtfs_benchmark new file mode 100755 index 0000000..de7c21e --- /dev/null +++ b/bin/xtfs_benchmark @@ -0,0 +1,54 @@ +#!/bin/bash + +check_xtreemfs() { + if [ -z "$XTREEMFS" ]; then + if [ -d java -a -d cpp -a -d etc ]; then + #echo "Looks like you are in an XtreemFS base directory..." + XTREEMFS=`pwd` + elif [ -d ../java -a -d ../cpp -a -d ../etc ]; then + #echo "XTREEMFS base could be the parent directory..." + XTREEMFS=`pwd`/.. + fi + fi + if [ ! -e "$XTREEMFS/java/servers/dist/XtreemFS.jar" -a ! -d "$XTREEMFS/java/lib" -a ! -f "/usr/share/java/XtreemFS.jar" ]; + then + echo "XtreemFS jar could not be found!" + exit 1 + fi +} + +check_java() { + if [ -z "$JAVA_HOME" -a ! -f "/usr/bin/java" ]; then + echo "\$JAVA_HOME not set, JDK/JRE 1.6 required" + exit 1 + fi + + if [ -z "$JAVA_HOME" ]; then + JAVA_HOME=/usr + fi + + JVERS=`$JAVA_HOME/bin/java -version 2>&1 | grep "java version" | \ + cut -d " " -f 3` + test "$JVERS" \> "\"1.6.0" + if [ $? -eq 1 ]; then + echo "Java version is $JVERS. You need JAVA 1.6!!!" + exit 1 + fi + + #echo "Java version $JVERS found under $JAVA_HOME" +} + + +check_xtreemfs +check_java + + + +# exec $JAVA_HOME/bin/java -Dcom.sun.sdp.conf=$XTREEMFS/sdp.conf -Dcom.sun.sdp.debug=sdp.log -Djava.net.preferIPv4Stack=true -ea -cp $XTREEMFS/java/servers/dist/XtreemFS.jar:$XTREEMFS/java/foundation/dist/Foundation.jar:$XTREEMFS/java/lib/*:/usr/share/java/XtreemFS.jar:/usr/share/java/protobuf-java-2.3.0.jar:/usr/share/java/Foundation.jar:. \ + # org.xtreemfs.utils.xtfs_benchmark.xtfs_benchmark $* + +exec $JAVA_HOME/bin/java -ea -cp $XTREEMFS/java/servers/dist/XtreemFS.jar:$XTREEMFS/java/foundation/dist/Foundation.jar:$XTREEMFS/java/lib/*:/usr/share/java/XtreemFS.jar:/usr/share/java/protobuf-java-2.3.0.jar:/usr/share/java/Foundation.jar:. \ + org.xtreemfs.utils.xtfs_benchmark.xtfs_benchmark $* + +# exec $JAVA_HOME/bin/java -agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=3128 -ea -cp $XTREEMFS/java/servers/dist/XtreemFS.jar:$XTREEMFS/java/foundation/dist/Foundation.jar:$XTREEMFS/java/lib/*:/usr/share/java/XtreemFS.jar:/usr/share/java/protobuf-java-2.3.0.jar:/usr/share/java/Foundation.jar:. \ + # org.xtreemfs.utils.xtfs_benchmark.xtfs_benchmark $* diff --git a/bin/xtfs_chstatus b/bin/xtfs_chstatus new file mode 100755 index 0000000..d269100 --- /dev/null +++ b/bin/xtfs_chstatus @@ -0,0 +1,46 @@ +#!/bin/bash + +check_xtreemfs() { + if [ -z "$XTREEMFS" ]; then + if [ -d java -a -d cpp -a -d etc ]; then + #echo "Looks like you are in an XtreemFS base directory..." + XTREEMFS=`pwd` + elif [ -d ../java -a -d ../cpp -a -d ../etc ]; then + #echo "XTREEMFS base could be the parent directory..." + XTREEMFS=`pwd`/.. + fi + fi + if [ ! -e "$XTREEMFS/java/servers/dist/XtreemFS.jar" -a ! -d "$XTREEMFS/java/lib" -a ! -f "/usr/share/java/XtreemFS.jar" ]; + then + echo "XtreemFS jar could not be found!" + exit 1 + fi +} + +check_java() { + if [ -z "$JAVA_HOME" -a ! -f "/usr/bin/java" ]; then + echo "\$JAVA_HOME not set, JDK/JRE 1.6 required" + exit 1 + fi + + if [ -z "$JAVA_HOME" ]; then + JAVA_HOME=/usr + fi + + JVERS=`$JAVA_HOME/bin/java -version 2>&1 | grep "java version" | \ + cut -d " " -f 3` + test "$JVERS" \> "\"1.6.0" + if [ $? -eq 1 ]; then + echo "Java version is $JVERS. You need JAVA 1.6!!!" + exit 1 + fi + + #echo "Java version $JVERS found under $JAVA_HOME" +} + + +check_xtreemfs +check_java + +exec $JAVA_HOME/bin/java -ea -cp $XTREEMFS/java/servers/dist/XtreemFS.jar:$XTREEMFS/java/foundation/dist/Foundation.jar:$XTREEMFS/java/lib/*:/usr/share/java/XtreemFS.jar:/usr/share/java/protobuf-java-2.5.0.jar:/usr/share/java/Foundation.jar:. \ + org.xtreemfs.utils.xtfs_chstatus $* diff --git a/bin/xtfs_cleanup b/bin/xtfs_cleanup new file mode 100755 index 0000000..2ca3013 --- /dev/null +++ b/bin/xtfs_cleanup @@ -0,0 +1,46 @@ +#!/bin/bash + +check_xtreemfs() { + if [ -z "$XTREEMFS" ]; then + if [ -d java -a -d cpp -a -d etc ]; then + #echo "Looks like you are in an XtreemFS base directory..." + XTREEMFS=`pwd` + elif [ -d ../java -a -d ../cpp -a -d ../etc ]; then + #echo "XTREEMFS base could be the parent directory..." + XTREEMFS=`pwd`/.. + fi + fi + if [ ! -e "$XTREEMFS/java/servers/dist/XtreemFS.jar" -a ! -d "$XTREEMFS/java/lib" -a ! -f "/usr/share/java/XtreemFS.jar" ]; + then + echo "XtreemFS jar could not be found!" + exit 1 + fi +} + +check_java() { + if [ -z "$JAVA_HOME" -a ! -f "/usr/bin/java" ]; then + echo "\$JAVA_HOME not set, JDK/JRE 1.6 required" + exit 1 + fi + + if [ -z "$JAVA_HOME" ]; then + JAVA_HOME=/usr + fi + + JVERS=`$JAVA_HOME/bin/java -version 2>&1 | grep "java version" | \ + cut -d " " -f 3` + test "$JVERS" \> "\"1.6.0" + if [ $? -eq 1 ]; then + echo "Java version is $JVERS. You need JAVA 1.6!!!" + exit 1 + fi + + #echo "Java version $JVERS found under $JAVA_HOME" +} + + +check_xtreemfs +check_java + +exec $JAVA_HOME/bin/java -ea -cp $XTREEMFS/java/servers/dist/XtreemFS.jar:$XTREEMFS/java/foundation/dist/Foundation.jar:$XTREEMFS/java/lib/*:/usr/share/java/XtreemFS.jar:/usr/share/java/protobuf-java-2.5.0.jar:/usr/share/java/Foundation.jar:. \ + org.xtreemfs.utils.xtfs_cleanup_osd $* diff --git a/bin/xtfs_mrcdbtool b/bin/xtfs_mrcdbtool new file mode 100755 index 0000000..7a5502f --- /dev/null +++ b/bin/xtfs_mrcdbtool @@ -0,0 +1,46 @@ +#!/bin/bash + +check_xtreemfs() { + if [ -z "$XTREEMFS" ]; then + if [ -d java -a -d cpp -a -d etc ]; then + #echo "Looks like you are in an XtreemFS base directory..." + XTREEMFS=`pwd` + elif [ -d ../java -a -d ../cpp -a -d ../etc ]; then + #echo "XTREEMFS base could be the parent directory..." + XTREEMFS=`pwd`/.. + fi + fi + if [ ! -e "$XTREEMFS/java/servers/dist/XtreemFS.jar" -a ! -d "$XTREEMFS/java/lib" -a ! -f "/usr/share/java/XtreemFS.jar" ]; + then + echo "XtreemFS jar could not be found!" + exit 1 + fi +} + +check_java() { + if [ -z "$JAVA_HOME" -a ! -f "/usr/bin/java" ]; then + echo "\$JAVA_HOME not set, JDK/JRE 1.6 required" + exit 1 + fi + + if [ -z "$JAVA_HOME" ]; then + JAVA_HOME=/usr + fi + + JVERS=`$JAVA_HOME/bin/java -version 2>&1 | grep "java version" | \ + cut -d " " -f 3` + test "$JVERS" \> "\"1.6.0" + if [ $? -eq 1 ]; then + echo "Java version is $JVERS. You need JAVA 1.6!!!" + exit 1 + fi + + #echo "Java version $JVERS found under $JAVA_HOME" +} + + +check_xtreemfs +check_java + +exec $JAVA_HOME/bin/java -ea -cp $XTREEMFS/java/servers/dist/XtreemFS.jar:$XTREEMFS/java/foundation/dist/Foundation.jar:$XTREEMFS/java/lib/*:/usr/share/java/XtreemFS.jar:/usr/share/java/protobuf-java-2.5.0.jar:/usr/share/java/Foundation.jar:. \ + org.xtreemfs.utils.xtfs_mrcdbtool $* diff --git a/bin/xtfs_remove_osd b/bin/xtfs_remove_osd new file mode 100755 index 0000000..e68f193 --- /dev/null +++ b/bin/xtfs_remove_osd @@ -0,0 +1,46 @@ +#!/bin/bash + +check_xtreemfs() { + if [ -z "$XTREEMFS" ]; then + if [ -d java -a -d cpp -a -d etc ]; then + #echo "Looks like you are in an XtreemFS base directory..." + XTREEMFS=`pwd` + elif [ -d ../java -a -d ../cpp -a -d ../etc ]; then + #echo "XTREEMFS base could be the parent directory..." + XTREEMFS=`pwd`/.. + fi + fi + if [ ! -e "$XTREEMFS/java/servers/dist/XtreemFS.jar" -a ! -d "$XTREEMFS/java/lib" -a ! -f "/usr/share/java/XtreemFS.jar" ]; + then + echo "XtreemFS jar could not be found!" + exit 1 + fi +} + +check_java() { + if [ -z "$JAVA_HOME" -a ! -f "/usr/bin/java" ]; then + echo "\$JAVA_HOME not set, JDK/JRE 1.6 required" + exit 1 + fi + + if [ -z "$JAVA_HOME" ]; then + JAVA_HOME=/usr + fi + + JVERS=`$JAVA_HOME/bin/java -version 2>&1 | grep "java version" | \ + cut -d " " -f 3` + test "$JVERS" \> "\"1.6.0" + if [ $? -eq 1 ]; then + echo "Java version is $JVERS. You need JAVA 1.6!!!" + exit 1 + fi + + #echo "Java version $JVERS found under $JAVA_HOME" +} + + +check_xtreemfs +check_java + +exec $JAVA_HOME/bin/java -ea -cp $XTREEMFS/java/servers/dist/XtreemFS.jar:$XTREEMFS/java/foundation/dist/Foundation.jar:$XTREEMFS/java/lib/*:/usr/share/java/XtreemFS.jar:/usr/share/java/protobuf-java-2.5.0.jar:/usr/share/java/Foundation.jar:. \ + org.xtreemfs.utils.xtfs_remove_osd $* diff --git a/bin/xtfs_scrub b/bin/xtfs_scrub new file mode 100755 index 0000000..718319c --- /dev/null +++ b/bin/xtfs_scrub @@ -0,0 +1,46 @@ +#!/bin/bash + +check_xtreemfs() { + if [ -z "$XTREEMFS" ]; then + if [ -d java -a -d cpp -a -d etc ]; then + #echo "Looks like you are in an XtreemFS base directory..." + XTREEMFS=`pwd` + elif [ -d ../java -a -d ../cpp -a -d ../etc ]; then + #echo "XTREEMFS base could be the parent directory..." + XTREEMFS=`pwd`/.. + fi + fi + if [ ! -e "$XTREEMFS/java/servers/dist/XtreemFS.jar" -a ! -d "$XTREEMFS/java/lib" -a ! -f "/usr/share/java/XtreemFS.jar" ]; + then + echo "XtreemFS jar could not be found!" + exit 1 + fi +} + +check_java() { + if [ -z "$JAVA_HOME" -a ! -f "/usr/bin/java" ]; then + echo "\$JAVA_HOME not set, JDK/JRE 1.6 required" + exit 1 + fi + + if [ -z "$JAVA_HOME" ]; then + JAVA_HOME=/usr + fi + + JVERS=`$JAVA_HOME/bin/java -version 2>&1 | grep "java version" | \ + cut -d " " -f 3` + test "$JVERS" \> "\"1.6.0" + if [ $? -eq 1 ]; then + echo "Java version is $JVERS. You need JAVA 1.6!!!" + exit 1 + fi + + #echo "Java version $JVERS found under $JAVA_HOME" +} + + +check_xtreemfs +check_java + +exec $JAVA_HOME/bin/java -ea -cp $XTREEMFS/java/servers/dist/XtreemFS.jar:$XTREEMFS/java/foundation/dist/Foundation.jar:$XTREEMFS/java/lib/*:/usr/share/java/XtreemFS.jar:/usr/share/java/protobuf-java-2.5.0.jar:/usr/share/java/Foundation.jar:. \ + org.xtreemfs.utils.xtfs_scrub.xtfs_scrub $* diff --git a/contrib/benchmark/benchmark.sh b/contrib/benchmark/benchmark.sh new file mode 100755 index 0000000..db617e4 --- /dev/null +++ b/contrib/benchmark/benchmark.sh @@ -0,0 +1,403 @@ +#!/bin/bash + +# the timeout for one execution of xtfs_benchmark +TIMEOUT=1500 + +# the timeout for one cleanup +TIMEOUT_CLEANUP=300 + +# the time to sleep after a cleanup +SLEEPTIME=600 + +# if false, the script will not sleep after a cleanup and after drop_caches +# (-v will set false) +SLEEP=true + +# the size of the basefile for random benchmarks +BASEFILE_SIZE="100g" + +# the directories for the logfiles and the results +LOG_BASE=${BENCH_LOG:-$HOME} +LOG_DIR="$LOG_BASE/log" +RESULT_DIR="$LOG_BASE/result" + +# Drops caches after each benchmark. Uncomment to activate +# cp "drop_caches" to "/usr/local/bin" and add "ALL ALL=NOPASSWD: /usr/local/bin/drop_caches" to sudoers file +DROP_CACHES=${BENCH_DROP_CACHES:-"/usr/local/bin/drop_caches"} +if [[ $DROP_CACHES != "false" ]]; then + DROP_CACHES_CALL="sudo ${DROP_CACHES}" +fi + +# IP and Port of the DIR +DIR=${BENCH_DIR:-"localhost:32638"} + +# IP and Port of the MRC +MRC=${BENCH_MRC:-"localhost:32636"} + +# space separed list of OSD_UUIDS, e.g. "osd1 osd2 ..." +OSD_UUIDS=${BENCH_OSD_UUIDS:-"test-osd0"} + +# stripe size for a volume +STRIPE_SIZE="128K" + +# request size for each I/O operation +REQUEST_SIZE=$STRIPE_SIZE + +# replication settings +REPLICATION_POLICY="" +REPLICATION_FACTOR=1 + +check_env(){ + # check XTREEMFS + if [ -z "$XTREEMFS" ]; then + if [ -d java -a -d cpp -a -d etc ]; then + #echo "Looks like you are in an XtreemFS base directory..." + XTREEMFS=`pwd` + elif [ -d ../java -a -d ../cpp -a -d ../etc ]; then + #echo "XTREEMFS base could be the parent directory..." + XTREEMFS=`pwd`/.. + fi + fi + if [ ! -e "$XTREEMFS/java/servers/dist/XtreemFS.jar" -a ! -d "$XTREEMFS/java/lib" -a ! -f "/usr/share/java/XtreemFS.jar" ]; + then + echo "XtreemFS jar could not be found!" + exit 1 + fi + + # check JAVA_HOME + if [ -z "$JAVA_HOME" -a ! -f "/usr/bin/java" ]; then + echo "\$JAVA_HOME not set, JDK/JRE 1.6 required" + exit 1 + fi + + if [ -z "$JAVA_HOME" ]; then + JAVA_HOME=/usr + fi + +} + +printUsage() { + cat << EOF + +Synopsis + $(basename $0) -t TYPE -s NUMBER [-x NUMBER] [-p POLICY -f NUMBER] [-b NUMBER -e NUMBER] [-r NUMBER] [-v] + Run a XtreemFS benchmark series, i.e. a series of benchmarks with increasing + numbers of threads. Logs are placed in \$HOME/log/, results in \$HOME/results + (can be changed at the head of the script). + + -t type + Type of benchmarks to run. Type can be either of the following: + sw sequential write + usw unaligned sequential write + sr sequential read + rw random write + rr random read + + -s size + Size of one benchmark, modifier K (for KiB), M (for MiB) or G (for GiB) is mandatory. + + -c size + Size of each read/write request, modifier K (for KiB), M (for MiB) or G (for GiB) is mandatory. + Defaults to 128K. + + -i size + Stripe size for each volume, modifier K (for KiB), M (for MiB) or G (for GiB) is mandatory. + Defaults to 128K. + + -p policy + Replication policy to use. Defaults to none. + + -f factor + Replication factor to use. Defaults to 1. + + -b number of threads to beginn the benchmark series + Minimum number of threads to be run as the benchmarks series. + The series will run benchmarks between the 'begin' and the 'end' number of threads. + + -e number of threads to end the benchmark series + Maximum number of threads to be run as the benchmarks series. + The series will run benchmarks between the 'begin' and the 'end' number of threads. + + -r repetitions + Number of times a benchmark is repeated. + + -v verbose + If set, bash debugging is enabled ('set -x') and sleeping after the benchmarks + is disabled. + +EOF +} + +init_params(){ + + check_env + + if ! [ -d $LOG_DIR ]; then + echo "$LOG_DIR doesn't existing. Creating $LOG_DIR..." + mkdir -p $LOG_DIR + fi + if ! [ -d $RESULT_DIR ]; then + echo "$RESULT_DIR doesn't existing. Creating $RESULT_DIR" + mkdir -p $RESULT_DIR + fi + + THREADS="$(seq $BEGIN $END)" + REPETITIONS="$(seq 1 $REPETITIONS)" + + # use second resolution in case multiple benchmarks are run per minute + NOW=$(date +"%y-%m-%d_%H-%M-%S") + # redirect stdout and stderr + exec 2> >(tee $LOG_DIR/$TYPE-$NOW.log) + exec > >(tee $RESULT_DIR/$TYPE-$NOW.csv) + + BASEFILE_SIZE=$(parse_size $BASEFILE_SIZE) + REQUEST_SIZE=$(parse_size $REQUEST_SIZE) + STRIPE_SIZE=$(parse_size $STRIPE_SIZE) + +} + + +parse_size(){ + local size_with_modifier=$1 + local index=$(echo `expr match $size_with_modifier '[0-9]\+'`) + local size=${size_with_modifier:0:$index} + local modifier=${size_with_modifier:$index} + + if [ $index != ${#size_with_modifier} ]; then + if [ $modifier = "K" ] || [ $modifier = "k" ]; then + size=$(echo "$size*2^10" | bc) + elif [ $modifier = "M" ] || [ $modifier = "m" ]; then + size=$(echo "$size*2^20" | bc) + elif [ $modifier = "G" ] || [ $modifier = "g" ]; then + size=$(echo "$size*2^30" | bc) + else + echo "Wrong size modifier. Only 'M' and 'G' are allowed" + exit 1 + fi + fi + + echo $size +} + + + +prepare_seq_read(){ + + local size=$1 + local threads=$2 + + # declare array of volume names + local volume_index=$(echo "$threads-1" | bc) + for i in $(seq 0 $volume_index); do VOLUMES[$i]=benchmark$i; done + + echo -e "\nPreparing sequential read benchmarks\n" >&2 + for i in $(seq 1 $threads); do + local index=$(echo "$i-1"|bc) + timeout --foreground $TIMEOUT $XTREEMFS/bin/xtfs_benchmark -sw -ssize $1 --no-cleanup --user $USER \ + ${VOLUMES[$index]} --stripe-size $STRIPE_SIZE --chunk-size $REQUEST_SIZE + done +} + +prepare_random(){ + + local threads=$1 + + # declare array of volume names + local volume_index=$(echo "$threads-1" | bc) + for i in $(seq 0 $volume_index); do VOLUMES[$i]=benchmark$i; done + + # calc basefile size and round to a number divideable through REQUEST_SIZE + local basefile_size=$(echo "(($BASEFILE_SIZE/$threads)/$REQUEST_SIZE)*$REQUEST_SIZE" | bc) + + echo -e "\nPreparing random benchmark: Creating a basefiles\n" >&2 + for i in $(seq 1 $threads); do + local index=$(echo "$i-1"|bc) + timeout --foreground $TIMEOUT $XTREEMFS/bin/xtfs_benchmark -rr -rsize $REQUEST_SIZE --no-cleanup-basefile --no-cleanup-volumes --user $USER \ + --basefile-size $basefile_size ${VOLUMES[$index]} --stripe-size $STRIPE_SIZE --chunk-size $REQUEST_SIZE + done +} + + +run_benchmark(){ + local benchType=$1 + local size=$2 + local threads=$3 + local replicationOpt="" + if [[ $REPLICATION_POLICY != "" ]]; then + replicationOpt="--replication-policy $REPLICATION_POLICY" + fi + + if [ $benchType = "sr" ]; then + XTREEMFS=$XTREEMFS timeout --foreground $TIMEOUT $XTREEMFS/bin/xtfs_benchmark -$benchType -ssize $size -n $threads --no-cleanup-volumes --user $USER \ + $replicationOpt --replication-factor $REPLICATION_FACTOR --chunk-size $REQUEST_SIZE --stripe-size $STRIPE_SIZE + elif [ $benchType = "sw" ] || [ $benchType = "usw" ]; then + XTREEMFS=$XTREEMFS timeout --foreground $TIMEOUT $XTREEMFS/bin/xtfs_benchmark -$benchType -ssize $size -n $threads --user $USER \ + $replicationOpt --replication-factor $REPLICATION_FACTOR --chunk-size $REQUEST_SIZE --stripe-size $STRIPE_SIZE + elif [ $benchType = "rw" ] || [ $benchType = "rr" ]; then + # calc basefile size and round to a number divideable through REQUEST_SIZE + local basefile_size=$(echo "(($BASEFILE_SIZE/$threads)/$REQUEST_SIZE)*$REQUEST_SIZE" | bc) + XTREEMFS=$XTREEMFS timeout --foreground $TIMEOUT $XTREEMFS/bin/xtfs_benchmark -$benchType -rsize $size --basefile-size $basefile_size -n $threads \ + --no-cleanup-basefile --no-cleanup-volumes --user $USER \ + $replicationOpt --replication-factor $REPLICATION_FACTOR --chunk-size $REQUEST_SIZE --stripe-size $STRIPE_SIZE + fi + + local bench_exit_status=$? + if [ $bench_exit_status -eq 124 ]; then + echo "The benchmark timed out (Timeout: $TIMEOUT)" >&2 + interrupted_exit + elif [ $bench_exit_status -ne 0 ]; then + echo "The benchmark did not finish with exit status 0" >&2 + interrupted_exit + fi + + # cleanup after *every* benchmark only for seq write benchmark + if [ $benchType = "sr" ]; then + cleanup_osd + fi +} + +delete_volumes(){ + local number_of_threads=$1 + local volume_index=$(echo "$number_of_threads-1" | bc) + for i in $(seq 0 $volume_index); do + rmfs.xtreemfs -f $MRC/benchmark$i >/dev/null + if [ $? -eq 0 ]; then + echo "Removed volume benchmark$i" >&2 + fi + done +} + +cleanup_osd(){ + for osd in $OSD_UUIDS; do + timeout --foreground $TIMEOUT_CLEANUP $XTREEMFS/bin/xtfs_cleanup -dir pbrpc://$DIR -wait -e -delete_volumes uuid:$osd >&2 + done + if $SLEEP; then + echo "Start Sleeping for $(echo "$SLEEPTIME/60"|bc) minutes at $(date)" >&2 + sleep $SLEEPTIME + echo "Finished Sleeping at $(date)" >&2 + fi + drop_caches +} + +interrupted_exit(){ + echo "Unexpected exit, cleaning up..." >&2 + SLEEP=false + delete_volumes $END + cleanup_osd + exit 1 +} + +drop_caches(){ + if [ -n "$DROP_CACHES_CALL" ]; then + echo "Dropping caches" >&2 + $DROP_CACHES_CALL + if $SLEEP; then + sleep 10 + fi + fi +} + +##### main ### + +trap "echo; echo 'Interrupt received '; interrupted_exit" INT + +# show usage if invoked without options/arguments +if [ $# -eq 0 ]; then + printUsage + exit 1 +fi + +# default values +BEGIN=1 +END=1 +REPETITIONS=1 + + +# parse options +while getopts ":t:s:c:i:b:e:r:p:f:v" opt; do + case $opt in + t) + if [ $OPTARG = "sw" ] || [ $OPTARG = "usw" ] || [ $OPTARG = "sr" ] || [ $OPTARG = "rw" ] || [ $OPTARG = "rr" ]; then + TYPE=$OPTARG + else + echo 'wrong argument to -t. Needs to be either "sw", "usw", "sr", "rw" or "rr"' + exit 1 + fi + ;; + s) + SIZE=$(parse_size $OPTARG) + ;; + c) + REQUEST_SIZE=$(parse_size $OPTARG) + ;; + i) + STRIPE_SIZE=$(parse_size $OPTARG) + ;; + b) + BEGIN=$OPTARG + ;; + e) + END=$OPTARG + ;; + r) + REPETITIONS=$OPTARG + ;; + p) + REPLICATION_POLICY=$OPTARG + ;; + f) + REPLICATION_FACTOR=$OPTARG + ;; + v) + SLEEP=false + set -x + ;; + \?) + echo "Invalid option: -$OPTARG" >&2 + exit 1 + ;; + :) + echo "Option -$OPTARG requires an argument." >&2 + exit 1 + ;; + esac +done + +init_params +drop_caches + +echo "Running:" $0 $@ >&2 + +for i in $THREADS; do + size="$(echo "$SIZE/$i"|bc)" + if [ $TYPE != "usw" ]; then + size="$(echo "($size/$REQUEST_SIZE)*$REQUEST_SIZE" | bc)" # round down to a size divideable through the REQUEST_SIZE + fi + + if [ $TYPE = "sr" ]; then + prepare_seq_read $size $i + cleanup_osd + elif [ $TYPE = "rw" ] || [ $TYPE = "rr" ]; then + prepare_random $i + fi + + for j in $REPETITIONS; do + echo "Start $i-Thread-Benchmark Nr. $j" >&2 + + run_benchmark $TYPE $size $i + + echo "Finished $i-Thread-Benchmark Nr. $j" >&2 + + done + + # seq write benchmarks run cleanup after every benchmark, so this would be redundant + if [ $TYPE != "sw" ] && [ $TYPE != "usw" ]; then + volume_index=$(echo "$i-1" | bc) + for i in $(seq 0 $volume_index); do + rmfs.xtreemfs -f $MRC/benchmark$i >&2 + echo "Remove volume benchmark$i" >&2 + done + cleanup_osd + fi + +done diff --git a/contrib/benchmark/drop_caches b/contrib/benchmark/drop_caches new file mode 100755 index 0000000..d83e2ce --- /dev/null +++ b/contrib/benchmark/drop_caches @@ -0,0 +1,3 @@ +#!/bin/bash + +/bin/bash -c "echo 3 > /proc/sys/vm/drop_caches" diff --git a/contrib/filter-MRC-dump-with-XSLT/filter_files.xslt b/contrib/filter-MRC-dump-with-XSLT/filter_files.xslt new file mode 100644 index 0000000..8adaab9 --- /dev/null +++ b/contrib/filter-MRC-dump-with-XSLT/filter_files.xslt @@ -0,0 +1,69 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + / + + + + + + + | + + + + | + + + + | + + + + + + + \ No newline at end of file diff --git a/contrib/ganglia-plugin/.project b/contrib/ganglia-plugin/.project new file mode 100644 index 0000000..3714cb1 --- /dev/null +++ b/contrib/ganglia-plugin/.project @@ -0,0 +1,17 @@ + + + ganglia-plugin + + + + + + org.python.pydev.PyDevBuilder + + + + + + org.python.pydev.pythonNature + + diff --git a/contrib/ganglia-plugin/.pydevproject b/contrib/ganglia-plugin/.pydevproject new file mode 100644 index 0000000..f8b45b0 --- /dev/null +++ b/contrib/ganglia-plugin/.pydevproject @@ -0,0 +1,10 @@ + + + + +Default +python 2.6 + +/ganglia-plugin/src + + diff --git a/contrib/ganglia-plugin/README.txt b/contrib/ganglia-plugin/README.txt new file mode 100644 index 0000000..3219512 --- /dev/null +++ b/contrib/ganglia-plugin/README.txt @@ -0,0 +1,6 @@ +How to use this plugin? + +- Make sure your ganglia installation supports python plugins. +- Copy plugin files from src directory to /usr/lib/ganglia/python_modules/ +- Copy configuration files configuration-files directory to /etc/ganglia/conf.d +- Alter configuration files to suite your needs. diff --git a/contrib/ganglia-plugin/config-files/xtfs-dir.pyconf b/contrib/ganglia-plugin/config-files/xtfs-dir.pyconf new file mode 100644 index 0000000..6f93903 --- /dev/null +++ b/contrib/ganglia-plugin/config-files/xtfs-dir.pyconf @@ -0,0 +1,61 @@ +modules { + module { + name = "xtfs-dir-plugin" + language = "python" + # The following params are examples only + param Host { + value = localhost + } + param Port { + value = 9001 + } + param CommunityString { + value = public + } + } +} + +collection_group { + collect_every = 60 + time_threshold = 10 + metric { + name = "dir_jvm_used_mem" + title = "used memory of the jvm" + value_threshold = 1 + } + metric { + name = "dir_jvm_free_mem" + title = "free memory of the jvm" + value_threshold = 1 + } + metric { + name = "dir_client_connections" + title = "number of Clients" + value_threshold = 1 + } + metric { + name = "dir_pending_requests" + title = "number of pending requests" + value_threshold = 1 + } + metric { + name = "addr_mapping_count" + title = "number of address mappings" + value_threshold = 1 + } + metric { + name = "service_count" + title = "number of services" + value_threshold = 1 + } + metric { + name = "dir_status" + title = "Status DIR" + } + metric { + name = "dir_uuid" + title = "DIR UUID" + } +} + + diff --git a/contrib/ganglia-plugin/config-files/xtfs-mrc.pyconf b/contrib/ganglia-plugin/config-files/xtfs-mrc.pyconf new file mode 100644 index 0000000..a6bd12a --- /dev/null +++ b/contrib/ganglia-plugin/config-files/xtfs-mrc.pyconf @@ -0,0 +1,56 @@ +modules { + module { + name = "xtfs-mrc-plugin" + language = "python" + # The following params are examples only + param Host { + value = localhost + } + param Port { + value = 9002 + } + param CommunityString { + value = public + } + } +} + +collection_group { + collect_every = 60 + time_threshold = 10 + metric { + name = "mrc_jvm_used_mem" + title = "used memory of the jvm" + value_threshold = 1 + } + metric { + name = "mrc_jvm_free_mem" + title = "free memory of the jvm" + value_threshold = 1 + } + metric { + name = "mrc_client_connections" + title = "number of Clients" + value_threshold = 1 + } + metric { + name = "mrc_pending_requests" + title = "number of pending requests" + value_threshold = 1 + } + metric { + name = "volumes_count" + title = "number of volumes" + value_threshold = 1 + } + metric { + name = "mrc_status" + title = "Status MRC" + } + metric { + name = "mrc_uuid" + title = "MRC UUID" + } +} + + diff --git a/contrib/ganglia-plugin/config-files/xtfs-osd.pyconf b/contrib/ganglia-plugin/config-files/xtfs-osd.pyconf new file mode 100644 index 0000000..56128f5 --- /dev/null +++ b/contrib/ganglia-plugin/config-files/xtfs-osd.pyconf @@ -0,0 +1,107 @@ +modules { + module { + name = "xtfs-osd-plugin" + language = "python" + # The following params are examples only + param Host { + value = localhost + } + param Port { + value = 9003 + } + param CommunityString { + value = public + } + } +} + +collection_group { + collect_every = 60 + time_threshold = 10 + metric { + name = "osd_jvm_used_mem" + title = "used memory of the jvm" + value_threshold = 1 + } + metric { + name = "osd_jvm_free_mem" + title = "free memory of the jvm" + value_threshold = 1 + } + metric { + name = "osd_client_connections" + title = "number of Clients" + value_threshold = 1 + } + metric { + name = "objects_received" + title = "objects received" + value_threshold = 1 + } + metric { + name = "repl_objects_received" + title = "replicated objects received" + value_threshold = 1 + } + metric { + name = "objects_transmitted" + title = "objects transmitted" + value_threshold = 1 + } + metric { + name = "repl_bytes_received" + title = "replicated bytes received" + value_threshold = 1 + } + metric { + name = "bytes_received" + title = "bytes received" + value_threshold = 1 + } + metric { + name = "bytes_transmitted" + title = "bytes transmitted" + value_threshold = 1 + } + metric { + name = "preproc_queue_length" + title = "preprocessing stage queue length" + value_threshold = 1 + } + metric { + name = "storage_queue_length" + title = "storage stage queue length" + value_threshold = 1 + } + metric { + name = "deletion_queue_length" + title = "deletion stage queue length" + value_threshold = 1 + } + metric { + name = "open_files" + title = "open files" + value_threshold = 1 + } + metric { + name = "deleted_files" + title = "deleted files" + value_threshold = 1 + } + metric { + name = "free_space" + title = "free space" + value_threshold = 100 + } + metric { + name = "osd_status" + title = "Status OSD" + } + metric { + name = "osd_uuid" + title = "OSD UUID" + } +} + + + \ No newline at end of file diff --git a/contrib/ganglia-plugin/src/xtfs-dir-plugin.py b/contrib/ganglia-plugin/src/xtfs-dir-plugin.py new file mode 100644 index 0000000..32f40ab --- /dev/null +++ b/contrib/ganglia-plugin/src/xtfs-dir-plugin.py @@ -0,0 +1,250 @@ +''' +Created on May 25, 2011 + +@author: bzcseife + +This is a python ganglia plugin which monitors the status of an DIR service of the XtreemFS +filesystem. It is intend to run on the same host as the DIR and gathers information of the DIR per +SNMP. Therefore you have to configure your DIR to provide a SNMP Agent on this host. + +''' +#TODO: If ganglia supports 64bit values uses 64bit integers instead of converting all 64 bit integers +#reported from the SNMP Agent to 32bit integers. + + +import random +from pysnmp.entity.rfc3413.oneliner import cmdgen +from pysnmp.entity.rfc3413.oneliner.cmdgen import UdpTransportTarget + + +descriptors = list() +Random_Max = 50 +Constant_Value = 50 + + + +#Get the used memory of the JVM +def JvmUsedMem(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 1, 0)) + if (errorStatus == False and errorIndication == None): + + return int(varBinds[0][1]/1024/1024) + else: + return 0 +#Get the free memory of the JVM +def JvmFreeMem(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 2, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + +#Get the number of client connections +def ClientConnections(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 8, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + + +#Get the number of pending requests +def PendingRequests(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 9, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#Get the number of address mappings registered +def AddressMappingCount(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 2, 1, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#Get the number of services registered +def ServiceCount(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 2, 2, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#get the status of the DIR +#OID: 1.3.6.1.4.1.38350.1.11.0 +def Status(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 11, 0)) + + if (errorStatus == False and errorIndication == None): + return str(varBinds[0][1]) + else: + return "OFFLINE" + +#get the UUID of the DIR +#OID: 1.3.6.1.4.1.38350.1.13.0 +def Uuid(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 13, 0)) + + if (errorStatus == False and errorIndication == None): + return str(varBinds[0][1]) + else: + return "Service not available" + +def metric_init(params): + + global descriptors + global Commmunity_String + global Snmp_Port + global authData + global transportTarget + + + if 'ComummunityString' in params: + Community_String = params['CommunityString'] + else: + Community_String = 'public' + + if 'Port' in params: + Snmp_Port = int(params['Port']) + if 'Host' in params: + Snmp_Host = params['Host'] + + authData = cmdgen.CommunityData('xtreemfs-agent', 'public') + transportTarget = cmdgen.UdpTransportTarget((Snmp_Host, Snmp_Port), 1, 0) + + d0 = {'name': 'dir_jvm_used_mem', + 'call_back': JvmUsedMem, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'both', + 'format': '%u', + 'description': 'The amount of memory the JVM uses currently.', + 'groups': 'dir'} + + d1 = {'name': 'dir_jvm_free_mem', + 'call_back': JvmFreeMem, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'both', + 'format': '%u', + 'description': 'The amount of free memory the JVM can still use.', + 'groups': 'dir'} + + d2 = {'name': 'dir_client_connections', + 'call_back': ClientConnections, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'clients', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of active client connection this DIR has currently to handle.', + 'groups': 'dir'} + + d3 = {'name': 'dir_pending_requests', + 'call_back': PendingRequests, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'pending requests', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of pending requests this DIR has enqueued.', + 'groups': 'dir'} + + d4 = {'name': 'addr_mapping_count', + 'call_back': AddressMappingCount, + 'time_max': 90, + #value_type: string | uint | float | double + 'value_type': 'uint', + #units: unit of your metric + 'units': 'mappings', + #slope: zero | positive | negative | both + #This value maps to the data source types defined for RRDTool + #If 'positive', RRD file generated will be of COUNTER type (calculating the rate of change) + #If 'negative', ???? + #'both' will be of GAUGE type (no calculations are performed, graphing only the value reported) + #If 'zero', the metric will appear in the "Time and String Metrics" or the "Constant Metrics" depending on the value_type of the m + 'slope': 'both', + #format: format string of your metric + #Must correspond to value_type otherwise value of your metric will be unpredictable (reference: http://docs.python.org/library/stdtypes.html#string-formatting) + 'format': '%u', + #description: description of your metric + 'description': 'The number of address mapping registered at the DIR.', + #groups (optional): groups your metric belongs to + 'groups': 'dir'} + + d5 = {'name': 'service_count', + 'call_back': ServiceCount, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'services', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of services registered at the DIR.', + 'groups': 'dir'} + + d6 = {'name': 'dir_status', + 'call_back': Status, + 'time_max': 90, + 'value_type': 'string', + 'units': '', + 'slope': 'zero', + 'format': '%s', + 'description': 'ONLINE if this DIR is running correctly, OFFLINE otherwise', + 'groups': 'dir'} + + d7 = {'name': 'dir_uuid', + 'call_back': Uuid, + 'time_max': 90, + 'value_type': 'string', + 'units': '', + 'slope': 'zero', + 'format': '%s', + 'description': 'UUID of the DIR running on this host', + 'groups': 'dir'} + + + descriptors = [d0, d1, d2, d3, d4, d5, d6, d7] + + return descriptors + +def metric_cleanup(): + '''Clean up the metric module.''' + pass + + +#for debugging purpose +if __name__ == '__main__': + params = {'CommunityString': 'public', 'Host': 'localhost', 'Port': 9001} + metric_init(params) + for d in descriptors: + v = d['call_back'](d['name']) + print 'value for %s is' % (d['name']) + print v + + + diff --git a/contrib/ganglia-plugin/src/xtfs-mrc-plugin.py b/contrib/ganglia-plugin/src/xtfs-mrc-plugin.py new file mode 100644 index 0000000..91bc396 --- /dev/null +++ b/contrib/ganglia-plugin/src/xtfs-mrc-plugin.py @@ -0,0 +1,221 @@ +''' +Created on May 25, 2011 + +@author: bzcseife + +This is a python ganglia plugin which monitors the status of an DIR service of the XtreemFS +filesystem. It is intend to run on the same host as the MRC and gathers information of the MRC per +SNMP. Therefore you have to configure your MRC to provide a SNMP Agent on this host. + +''' +#TODO: If ganglia supports 64bit values uses 64bit integers instead of converting all 64 bit integers +#reported from the SNMP Agent to 32bit integers. + + +import random +from pysnmp.entity.rfc3413.oneliner import cmdgen +from pysnmp.entity.rfc3413.oneliner.cmdgen import UdpTransportTarget + + +descriptors = list() +Random_Max = 50 +Constant_Value = 50 + + + +#Get the used memory of the JVM +def JvmUsedMem(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 1, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + +#Get the free memory of the JVM +def JvmFreeMem(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 2, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + + +#Get the number of client connections +def ClientConnections(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 7, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + + +#Get the number of pending requests +def PendingRequests(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 8, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#Get the number of volumes +def VolumeCount(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 3, 2, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#get the status of the MRC +def Status(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 11, 0)) + + if (errorStatus == False and errorIndication == None): + return str(varBinds[0][1]) + else: + return "OFFLINE" + + +#get the UUID of the MRC +#OID: 1.3.6.1.4.1.38350.1.13.0 +def Uuid(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 13, 0)) + + if (errorStatus == False and errorIndication == None): + return str(varBinds[0][1]) + else: + return "Service not available" + + +def metric_init(params): + + global descriptors + global Commmunity_String + global Snmp_Port + global authData + global transportTarget + + + if 'ComummunityString' in params: + Community_String = params['CommunityString'] + else: + Community_String = 'public' + + if 'Port' in params: + Snmp_Port = int(params['Port']) + if 'Host' in params: + Snmp_Host = params['Host'] + + authData = cmdgen.CommunityData('xtreemfs-agent', 'public') + transportTarget = cmdgen.UdpTransportTarget((Snmp_Host, Snmp_Port),1 ,0) + + d0 = {'name': 'mrc_jvm_used_mem', + 'call_back': JvmUsedMem, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'both', + 'format': '%u', + 'description': 'The amount of memory the JVM uses currently.', + 'groups': 'mrc'} + + d1 = {'name': 'mrc_jvm_free_mem', + 'call_back': JvmFreeMem, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'both', + 'format': '%u', + 'description': 'The amount of free memory the JVM can still use.', + 'groups': 'mrc'} + + d2 = {'name': 'mrc_client_connections', + 'call_back': ClientConnections, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'clients', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of active client connection this MRC has currently to handle.', + 'groups': 'mrc'} + + d3 = {'name': 'mrc_pending_requests', + 'call_back': PendingRequests, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'pending requests', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of pending requests this MRC has enqueued.', + 'groups': 'mrc'} + + d4 = {'name': 'volumes_count', + 'call_back': VolumeCount, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'volumes', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of volumes on this MRC.', + 'groups': 'mrc'} + + d5 = {'name': 'mrc_status', + 'call_back': Status, + 'time_max': 90, + 'value_type': 'string', + 'units': '', + 'slope': 'zero', + 'format': '%s', + 'description': 'ONLINE if this OSD is running correctly, OFFLINE otherwise', + 'groups': 'mrc'} + + d6 = {'name': 'mrc_uuid', + 'call_back': Uuid, + 'time_max': 90, + 'value_type': 'string', + 'units': '', + 'slope': 'zero', + 'format': '%s', + 'description': 'UUID of the MRC running on this host', + 'groups': 'mrc'} + + + + descriptors = [d0, d1, d2, d3, d4, d5, d6 ] + + return descriptors + +def metric_cleanup(): + '''Clean up the metric module.''' + pass + + +#for debugging purpose +if __name__ == '__main__': + params = {'CommunityString': 'public', 'Host': 'localhost', 'Port': 9002} + metric_init(params) + for d in descriptors: + v = d['call_back'](d['name']) + print 'value for %s is ' % (d['name']) + print v + + + diff --git a/contrib/ganglia-plugin/src/xtfs-osd-plugin.py b/contrib/ganglia-plugin/src/xtfs-osd-plugin.py new file mode 100644 index 0000000..e2fc721 --- /dev/null +++ b/contrib/ganglia-plugin/src/xtfs-osd-plugin.py @@ -0,0 +1,477 @@ +''' +Created on May 25, 2011 + +@author: bzcseife + +This is a python ganglia plugin which monitors the status of an OSD service of the XtreemFS +filesystem. It is intend to run on the same host as the OSD and gathers information of the OSD per +SNMP. Therefore you have to configure your OSD to provide a SNMP Agent on this host. + +''' +#TODO: If ganglia supports 64bit values uses 64bit integers instead of converting all 64 bit integers +#reported from the SNMP Agent to 32bit integers. + + +import random +from pysnmp.entity.rfc3413.oneliner import cmdgen +from pysnmp.entity.rfc3413.oneliner.cmdgen import UdpTransportTarget + + + + +descriptors = list() +Random_Max = 50 +Constant_Value = 50 + + + +#Get the used memory of the JVM +def JvmUsedMem(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 1, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + + + +#Get the free memory of the JVM +def JvmFreeMem(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 2, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + + +#Get the number of client connections +def ClientConnections(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 7, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + + +#Get the number of pending requests +def PendingRequests(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 8, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#Get the number of objects received +def ObjectsReceived(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 1, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#Get the number of replicated objects received +def ReplObjectsReceived(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 2, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#Get the number of replicated objects transmitted +def ObjectsTransmitted(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 3, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#Get the number of replicated bytes received +def ReplBytesReceived(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 4, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + +#Get the number of bytes received +def BytesReceived(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 5, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + +#Get the number of bytes transmitted +def BytesTransmitted(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 6, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + +#Get the length of the preprocessing stage queue +def PreprocQueueLength(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 7, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + +#Get the length of the storage stage queue +def StorageQueueLength(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 8, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + +#Get the length of the deletion stage queue +def DeletionQueueLength(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 9, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + + +#Get the number of open files from the OSD per snmp +def OsdOpenFiles(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 10, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + + + +#Get the number of deleted files from the OSD per snmp +def OsdDeletedFiles(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 11, 0)) + + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1]) + else: + return 0 + + +#Get the free space from the OSD per snmp +def OsdFreeSpace(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 4, 12, 0)) + if (errorStatus == False and errorIndication == None): + return int(varBinds[0][1] / 1024 / 1024) + else: + return 0 + +#get the status of the OSD +def Status(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 11, 0)) + + if (errorStatus == False and errorIndication == None): + return str(varBinds[0][1]) + else: + return "OFFLINE" + +#get the UUID of the OSD +#OID: 1.3.6.1.4.1.38350.1.13.0 +def Uuid(name): + errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData, + transportTarget, + (1, 3, 6, 1, 4, 1, 38350, 1, 13, 0)) + + if (errorStatus == False and errorIndication == None): + return str(varBinds[0][1]) + else: + return "Service not available" + +def metric_init(params): + + global descriptors + global Commmunity_String + global Snmp_Port + global authData + global transportTarget + + + if 'ComummunityString' in params: + Community_String = params['CommunityString'] + else: + Community_String = 'public' + + if 'Port' in params: + Snmp_Port = int(params['Port']) + if 'Host' in params: + Snmp_Host = params['Host'] + + authData = cmdgen.CommunityData('xtreemfs-agent', 'public') + transportTarget = cmdgen.UdpTransportTarget((Snmp_Host, Snmp_Port),1,0) + + d0 = {'name': 'osd_jvm_used_mem', + 'call_back': JvmUsedMem, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'both', + 'format': '%u', + 'description': 'The amount of memory the JVM uses currently.', + 'groups': 'osd'} + + d1 = {'name': 'osd_jvm_free_mem', + 'call_back': JvmFreeMem, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'both', + 'format': '%u', + 'description': 'The amount of free memory the JVM can still use.', + 'groups': 'osd'} + + d2 = {'name': 'osd_client_connections', + 'call_back': ClientConnections, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'clients', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of active client connection this OSD has currently to handle.', + 'groups': 'osd'} + + d3 = {'name': 'osd_pending_requests', + 'call_back': PendingRequests, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'pending requests', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of pending requests this OSD has enqueued.', + 'groups': 'osd'} + + d4 = {'name': 'objects_received', + 'call_back': ObjectsReceived, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'objects', + 'slope': 'positive', + 'format': '%u', + 'description': 'The number of objects this OSD has received.', + 'groups': 'osd'} + + d5 = {'name': 'repl_objects_received', + 'call_back': ReplObjectsReceived, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'objects', + 'slope': 'positive', + 'format': '%u', + 'description': 'The number of replicated objects this OSD has received.', + 'groups': 'osd'} + + d6 = {'name': 'objects_transmitted', + 'call_back': ObjectsTransmitted, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'objects', + 'slope': 'positive', + 'format': '%u', + 'description': 'The number of objects this OSD has transmitted.', + 'groups': 'osd'} + + d7 = {'name': 'repl_bytes_received', + 'call_back': ReplBytesReceived, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'positive', + 'format': '%u', + 'description': 'The number of replicated bytes this OSD has received.', + 'groups': 'osd'} + + d8 = {'name': 'bytes_received', + 'call_back': BytesReceived, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'positive', + 'format': '%u', + 'description': 'The number of bytes this OSD has received.', + 'groups': 'osd'} + + d9 = {'name': 'bytes_transmitted', + 'call_back': BytesTransmitted, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'Megabytes', + 'slope': 'positive', + 'format': '%u', + 'description': 'The number of bytes this OSD has transmitted.', + 'groups': 'osd'} + + d10 = {'name': 'preproc_queue_length', + 'call_back': PreprocQueueLength, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'requests', + 'slope': 'both', + 'format': '%u', + 'description': 'The length of the preprocessing stage queue of this OSD.', + 'groups': 'osd'} + + d11 = {'name': 'storage_queue_length', + 'call_back': StorageQueueLength, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'requests', + 'slope': 'positive', + 'format': '%u', + 'description': 'The length of the storage stage queue of this OSD.', + 'groups': 'osd'} + + d12 = {'name': 'deletion_queue_length', + 'call_back': DeletionQueueLength, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'requests', + 'slope': 'both', + 'format': '%u', + 'description': 'The length of the deletion stage queue of this OSD.', + 'groups': 'osd'} + + d13 = {'name': 'storage_queue_length', + 'call_back': StorageQueueLength, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'requests', + 'slope': 'both', + 'format': '%u', + 'description': 'The length of the storage stage queue of this OSD.', + 'groups': 'osd'} + + d14 = {'name': 'open_files', + 'call_back': OsdOpenFiles, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'files', + 'slope': 'both', + 'format': '%u', + 'description': 'The number of file this OSD has currently opened.', + 'groups': 'osd'} + + d15 = {'name': 'deleted_files', + 'call_back': OsdDeletedFiles, + 'time_max': 90, + 'value_type': 'uint', + 'units': 'files', + 'slope': 'positive', + 'format': '%u', + 'description': 'The number of deleted files on this OSD', + 'groups': 'osd'} + + + d16 = {'name': 'free_space', + 'call_back': OsdFreeSpace, + 'time_max': 90, + #value_type: string | uint | float | double + 'value_type': 'uint', + #units: unit of your metric + 'units': 'Megabytes', + #slope: zero | positive | negative | both + #This value maps to the data source types defined for RRDTool + #If 'positive', RRD file generated will be of COUNTER type (calculating the rate of change) + #If 'negative', ???? + #'both' will be of GAUGE type (no calculations are performed, graphing only the value reported) + #If 'zero', the metric will appear in the "Time and String Metrics" or the "Constant Metrics" depending on the value_type of the m + 'slope': 'both', + #format: format string of your metric + #Must correspond to value_type otherwise value of your metric will be unpredictable (reference: http://docs.python.org/library/stdtypes.html#string-formatting) + 'format': '%u', + #description: description of your metric + 'description': 'The free disc space on the partition this OSD stores the object files.', + #groups (optional): groups your metric belongs to + 'groups': 'osd'} + + d17 = {'name': 'osd_status', + 'call_back': Status, + 'time_max': 90, + 'value_type': 'string', + 'units': '', + 'slope': 'zero', + 'format': '%s', + 'description': 'ONLINE if this OSD is running correctly, OFFLINE otherwise', + 'groups': 'osd'} + + d18 = {'name': 'osd_uuid', + 'call_back': Uuid, + 'time_max': 90, + 'value_type': 'string', + 'units': '', + 'slope': 'zero', + 'format': '%s', + 'description': 'UUID of the OSD running on this host', + 'groups': 'osd'} + + descriptors = [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18] + + return descriptors + +def metric_cleanup(): + '''Clean up the metric module.''' + pass + + +#for debugging purpose +if __name__ == '__main__': + params = {'CommunityString': 'public', 'Host': 'localhost', 'Port': 9003} + metric_init(params) + for d in descriptors: + v = d['call_back'](d['name']) + print 'value for %s is' % (d['name']) + print v + + diff --git a/contrib/osd-health/osd_health_check.sh b/contrib/osd-health/osd_health_check.sh new file mode 100755 index 0000000..068de1c --- /dev/null +++ b/contrib/osd-health/osd_health_check.sh @@ -0,0 +1,37 @@ +#!/bin/bash + +OBJECT_DIR=$1 + +# get device for object_dir +IFS=' ' read -r DEVICE TMP <<< $(df $OBJECT_DIR | grep dev) + +# Determine device type +if [[ $DEVICE == *md* ]]; then + # DEVICE is a RAID configuration + DEVICES=$(IFS=' ' read -a TMP <<< $(cat /proc/mdstat | grep $DEVICE)) + DEVICES=${DEVICES[@]:4} +elif [[ $DEVICE == *sd* || $DEVICE == *hd* ]]; then + # DEVICE is a single disk + DEVICES=$DEVICE +else + # unsupported device type + echo "unsupported device type" + exit 3 +fi + +for DEVICE in $DEVICES; do + SMART_STATUS="$(sudo smartctl --health $DEVICE)" + echo $SMART_STATUS + if [[ $SMART_STATUS == *PASSED* ]] + then + continue; + elif [[ $SMART_STATUS == *FAILED* ]] + then + exit 1 + else + exit 3 + fi +done + +# If no device's health test failed, return 0 (i.e. health test PASSED). +exit 0 diff --git a/contrib/server-repl-plugin/BabuDB_replication_plugin.jar b/contrib/server-repl-plugin/BabuDB_replication_plugin.jar new file mode 100644 index 0000000..9c2114e Binary files /dev/null and b/contrib/server-repl-plugin/BabuDB_replication_plugin.jar differ diff --git a/contrib/server-repl-plugin/LICENSE b/contrib/server-repl-plugin/LICENSE new file mode 100644 index 0000000..2f35497 --- /dev/null +++ b/contrib/server-repl-plugin/LICENSE @@ -0,0 +1,32 @@ +Copyright (c) 2008-2011, Jan Stender, Bjoern Kolbeck, Mikael Hoegqvist, + Felix Hupfeld, Felix Langner, Zuse Institute Berlin +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + * Neither the name of the Zuse Institute Berlin nor the + names of its contributors may be used to endorse or promote + products derived from this software without specific prior + written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/contrib/server-repl-plugin/README b/contrib/server-repl-plugin/README new file mode 100644 index 0000000..c364af4 --- /dev/null +++ b/contrib/server-repl-plugin/README @@ -0,0 +1,3 @@ +For further details on how to use the BabuDB replication plug-in, please refer to the BabuDB Wiki: + +http://code.google.com/p/babudb/wiki/UsageReplicationForJava \ No newline at end of file diff --git a/contrib/server-repl-plugin/config/dir.properties b/contrib/server-repl-plugin/config/dir.properties new file mode 100644 index 0000000..bf25913 --- /dev/null +++ b/contrib/server-repl-plugin/config/dir.properties @@ -0,0 +1,82 @@ +##################################################################### +# BabuDB replication plugin configuration (DIR replication) # +##################################################################### + +##################################################################### +# List of replicas and replication configuration +##################################################################### + +# participants of the replication including this replica +babudb.repl.participant.0 = first-DIR-replica +babudb.repl.participant.0.port = 35678 +babudb.repl.participant.1 = second-DIR-replica +babudb.repl.participant.1.port = 35678 +babudb.repl.participant.2 = third-DIR-replica +babudb.repl.participant.2.port = 35678 + +# number of servers that at least have to be up to date +# To have a fault-tolerant system, this value has to be set to the +# majority of nodes i.e., if you have three replicas, set this to 2 +# Please note that a setup with two nodes provides no fault-tolerance. +babudb.repl.sync.n = 2 + +##################################################################### +# Advanced Options (usually you do NOT have to edit these) +##################################################################### + +# It's possible to set the local address and port of this server explicitly. +# If not, it will be chosen from the list of participants. +#babudb.repl.localhost = localhost +#babudb.repl.localport = 35678 + +# Choose here one of the predefined policies for handling database requests: +# +# MasterOnly - Redirect any kind of request to the master. +# Provides strong consistency. +# WriteRestriction - Same as MasterOnly plus lookup operations are also permitted on the slaves. +# Consequently, clients may read stale values from a backup replica. +# NoRestriction - Allows any kind of request to be performed at the local BabuDB instance. +# May result into conflicts which are not resolved. +# +# default setting is MasterOnly. +#babudb.repl.policy = MasterOnly + +# DB backup directory - needed for the initial loading of the BabuDB from the +# master in replication context +babudb.repl.backupDir = /var/lib/xtreemfs/server-repl-dir + +##################################################################### +# SSL options (disabled by default) +##################################################################### + +# specify whether SSL is required +#babudb.ssl.enabled = false + +# server credentials for SSL handshakes +#babudb.ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12 +#babudb.ssl.service_creds.pw = xtreemfs +#babudb.ssl.service_creds.container = pkcs12 + +# trusted certificates for SSL handshakes +#babudb.ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/xosrootca.jks +#babudb.ssl.trusted_certs.pw = xtreemfs +#babudb.ssl.trusted_certs.container = jks + +#babudb.ssl.authenticationWithoutEncryption = false + +##################################################################### +# Internal options (usually do not have to be touched) +##################################################################### +plugin.jar = /usr/share/java/BabuDB_replication_plugin.jar + +# paths to libraries this plugin depends on +babudb.repl.dependency.0 = /usr/share/java/Flease.jar + +# local time renew in milliseconds +#babudb.localTimeRenew = 0 + +# chunk size, for initial load of file chunks +#babudb.repl.chunkSize = 5242880 + +# decides whether redirects should be handled by the user-application or not +#babudb.repl.redirectIsVisible = false diff --git a/contrib/server-repl-plugin/config/mrc.properties b/contrib/server-repl-plugin/config/mrc.properties new file mode 100644 index 0000000..2ec33cb --- /dev/null +++ b/contrib/server-repl-plugin/config/mrc.properties @@ -0,0 +1,82 @@ +##################################################################### +# BabuDB replication plugin configuration (MRC replication) # +##################################################################### + +##################################################################### +# List of replicas and replication configuration +##################################################################### + +# participants of the replication including this replica +babudb.repl.participant.0 = first-MRC-replica +babudb.repl.participant.0.port = 35676 +babudb.repl.participant.1 = second-MRC-replica +babudb.repl.participant.1.port = 35676 +babudb.repl.participant.2 = third-MRC-replica +babudb.repl.participant.2.port = 35676 + +# number of servers that at least have to be up to date +# To have a fault-tolerant system, this value has to be set to the +# majority of nodes i.e., if you have three replicas, set this to 2 +# Please note that a setup with two nodes provides no fault-tolerance. +babudb.repl.sync.n = 2 + +##################################################################### +# Advanced Options (usually you do NOT have to edit these) +##################################################################### + +# It's possible to set the local address and port of this server explicitly. +# If not, it will be chosen from the list of participants. +#babudb.repl.localhost = localhost +#babudb.repl.localport = 35676 + +# Choose here one of the predefined policies for handling database requests: +# +# MasterOnly - Redirect any kind of request to the master. +# Provides strong consistency. +# WriteRestriction - Same as MasterOnly plus lookup operations are also permitted on the slaves. +# Consequently, clients may read stale values from a backup replica. +# NoRestriction - Allows any kind of request to be performed at the local BabuDB instance. +# May result into conflicts which are not resolved. +# +# default setting is MasterOnly. +#babudb.repl.policy = MasterOnly + +# DB backup directory - needed for the initial loading of the BabuDB from the +# master in replication context +babudb.repl.backupDir = /var/lib/xtreemfs/server-repl-mrc + +##################################################################### +# SSL options (disabled by default) +##################################################################### + +# specify whether SSL is required +#babudb.ssl.enabled = false + +# server credentials for SSL handshakes +#babudb.ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12 +#babudb.ssl.service_creds.pw = xtreemfs +#babudb.ssl.service_creds.container = pkcs12 + +# trusted certificates for SSL handshakes +#babudb.ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/xosrootca.jks +#babudb.ssl.trusted_certs.pw = xtreemfs +#babudb.ssl.trusted_certs.container = jks + +#babudb.ssl.authenticationWithoutEncryption = false + +##################################################################### +# Internal options (usually do not have to be touched) +##################################################################### +plugin.jar = /usr/share/java/BabuDB_replication_plugin.jar + +# paths to libraries this plugin depends on +babudb.repl.dependency.0 = /usr/share/java/Flease.jar + +# local time renew in milliseconds +#babudb.localTimeRenew = 0 + +# chunk size, for initial load of file chunks +#babudb.repl.chunkSize = 5242880 + +# decides whether redirects should be handled by the user-application or not +#babudb.repl.redirectIsVisible = false diff --git a/contrib/server-repl-plugin/update_BabuDB_replication_plugin_jar.sh b/contrib/server-repl-plugin/update_BabuDB_replication_plugin_jar.sh new file mode 100755 index 0000000..11fa3ce --- /dev/null +++ b/contrib/server-repl-plugin/update_BabuDB_replication_plugin_jar.sh @@ -0,0 +1,60 @@ +#!/bin/bash + +# Copyright (c) 2012 Michael Berlin, Zuse Institute Berlin +# Licensed under the BSD License, see LICENSE file for details. + +set -e + +trap onexit 1 2 3 15 ERR + +function onexit() { + local exit_status=${1:-$?} + echo ERROR: Exiting $0 with $exit_status + exit $exit_status +} + +replication_dir_in_babudb_trunk="java/replication" + +cat </dev/null +ant jar -f "$babudb_replication_buildfile" >/dev/null +cp -a "$babudb_replication_jar_source" "$babudb_replication_jar_dest" + +echo "finished compiling BabuDB replication plugion (BabuDB_replication_plugin.jar)" diff --git a/contrib/travis/parse_results.py b/contrib/travis/parse_results.py new file mode 100755 index 0000000..fc32124 --- /dev/null +++ b/contrib/travis/parse_results.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python + +# Copyright (c) 2014 by Johannes Dillmann, Zuse Institute Berlin +# Licensed under the BSD License, see LICENSE file for details. + +import sys + +import argparse +import json + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("file", type=argparse.FileType('r')) + parser.add_argument("test") + args = parser.parse_args() + + results = json.load(args.file) + result = None + + if args.test in results: + result = results[args.test] + + if type(result) == bool and result: + print "true" + sys.exit(0) + + if type(result) == dict and all(result.values()): + print "true" + sys.exit(0) + + print "false" + sys.exit(1) + diff --git a/contrib/vagrant/provision.sh b/contrib/vagrant/provision.sh new file mode 100644 index 0000000..a24f674 --- /dev/null +++ b/contrib/vagrant/provision.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash + +echo "Installing XtreemFS build dependencies" +apt-get -y update +apt-get -y install openjdk-7-jdk ant build-essential libssl-dev libfuse-dev libattr1-dev cmake libboost-regex-dev libboost-program-options-dev libboost-thread-dev libboost-system-dev valgrind +echo "export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64" >> /etc/bash.bashrc +echo "export BUILD_CLIENT_TESTS=true" >> /etc/bash.bashrc diff --git a/contrib/xtreemfs-osd-farm/xtreemfs-osd-farm b/contrib/xtreemfs-osd-farm/xtreemfs-osd-farm new file mode 100755 index 0000000..8260843 --- /dev/null +++ b/contrib/xtreemfs-osd-farm/xtreemfs-osd-farm @@ -0,0 +1,223 @@ +#!/bin/bash + +### BEGIN INIT INFO +# Provides: xtreemfs-osd-farm +# Required-Start: $network $remote_fs +# Required-Stop: $network $remote_fs +# Should-Start: xtreemfs-dir +# Should-Stop: $null +# Default-Start: 3 5 +# Default-Stop: 0 1 2 6 +# Short-Description: XtreemFS OSD init.d script which can start multiple OSDs on the same machine in contrast to xtreemfs-osd +# Description: XtreemFS Object Storage Device (OSD). http://www.xtreemfs.org/ +### END INIT INFO + +# Source function library. +if [ -e /lib/lsb/init-functions ]; then + . /lib/lsb/init-functions +else + . /etc/init.d/functions +fi + +XTREEMFS_USER=xtreemfs + +# List of OSD instances which shall be started, seperated by spaces. +# For every OSD there has to be a configuration file. +OSD_INSTANCES="osd1 osd2 osd3" + +# OSD specific options. Use %OSDNAME% which will be substituted. +PID_OSD_GENERIC=/var/run/xtreemfs_%OSDNAME%.pid + +CONFIG_OSD_GENERIC=/etc/xos/xtreemfs/%OSDNAME%.config.properties + +LOG_OSD_GENERIC=/var/log/xtreemfs/%OSDNAME%.log + +if [ -z $JAVA_HOME ]; then + export JAVA_HOME=/usr +fi +JAVA_CALL="$JAVA_HOME/bin/java -ea -cp /usr/share/java/XtreemFS.jar:/usr/share/java/BabuDB.jar:/usr/share/java/Flease.jar:/usr/share/java/protobuf-java-2.5.0.jar:/usr/share/java/Foundation.jar:/usr/share/java/jdmkrt.jar:/usr/share/java/jdmktk.jar:/usr/share/java/commons-codec-1.3.jar" + +# For SELinux we need to use 'runuser' not 'su' +if [ -x "/sbin/runuser" ]; then + SU="/sbin/runuser" +else + SU="/bin/su" +fi + +pre_check() { + LOG_OSD="$1" + CONFIG_OSD="$2" + exists=`grep -c $XTREEMFS_USER /etc/passwd` + if [ $exists -eq 0 ]; then + echo "User $XTREEMFS_USER does not exist. Create it first." + exit 1 + fi + log_directory=`dirname $LOG_OSD` + if [ ! -e $log_directory ]; then + echo "Directory for logfiles $log_directory does not exist. Create it first." + exit 1 + fi + + if [ ! -f "$CONFIG_OSD" ]; then + echo -e "Config file not found: $CONFIG_OSD" + echo + exit 1 + fi +} + +get_osd_list() { + OSD_LIST="" + if [ -n "$1" ]; then + # Check if given OSD name in list of allowed OSDs. + for osd in $OSD_INSTANCES; do + [ "$osd" = "$1" ] && OSD_LIST="$1" && return 0 + done + + echo "OSD \"$1\" is not part of the list OSD_INSTANCES." + exit 1 + else + OSD_LIST=$OSD_INSTANCES + return 0 + fi +} + +substitute_osdname() { + echo "$1" | sed -e "s/%OSDNAME%/$2/g" +} + +pre_check_vars() { + for var in $LOG_OSD_GENERIC $PID_OSD_GENERIC $CONFIG_OSD_GENERIC; do + echo "$var" | grep %OSDNAME% >/dev/null || { + echo "%OSDNAME% parameter not found in variable: $var" + exit 1 + } + done +} + +start() { + get_osd_list "$1" + pre_check_vars + + for osdname in $OSD_LIST; do + LOG_OSD=$(substitute_osdname "$LOG_OSD_GENERIC" "$osdname") + PID_OSD=$(substitute_osdname "$PID_OSD_GENERIC" "$osdname") + CONFIG_OSD=$(substitute_osdname "$CONFIG_OSD_GENERIC" "$osdname") + + pre_check "$LOG_OSD" "$CONFIG_OSD" + + echo >> $LOG_OSD + date >> $LOG_OSD + echo -e "Starting XtreemFS Object Storage Device (OSD): $osdname ... \n\n" >> $LOG_OSD + + echo -n "Starting XtreemFS Object Storage Device (OSD): $osdname ... " + $SU -s /bin/bash $XTREEMFS_USER -c "$JAVA_CALL org.xtreemfs.osd.OSD $CONFIG_OSD" >> $LOG_OSD 2>&1 & + PROCPID=$! + echo $PROCPID > $PID_OSD + sleep 1s + + if [ -e /proc/$PROCPID ]; then + echo "success" + else + echo "failed" + return 1 + fi + + done + + return 0 +} + +stop() { + get_osd_list "$1" + pre_check_vars + + for osdname in $OSD_LIST; do + LOG_OSD=$(substitute_osdname "$LOG_OSD_GENERIC" "$osdname") + PID_OSD=$(substitute_osdname "$PID_OSD_GENERIC" "$osdname") + CONFIG_OSD=$(substitute_osdname "$CONFIG_OSD_GENERIC" "$osdname") + + result=0 + if [ -f $PID_OSD ]; then + echo -n "Stopping XtreemFS Object Storage Device (OSD): $osdname ... " + killproc -p $PID_OSD $SU + result=$? + if [ $result -eq 0 ]; then + rm -f $PID_OSD + echo "success" + else + echo "failed" + fi + else + echo "XtreemFS Object Storage Device (OSD) is not running" + fi + + done + return $result +} + +status() { + get_osd_list "$1" + pre_check_vars + + rc=0 + for osdname in $OSD_LIST; do + LOG_OSD=$(substitute_osdname "$LOG_OSD_GENERIC" "$osdname") + PID_OSD=$(substitute_osdname "$PID_OSD_GENERIC" "$osdname") + CONFIG_OSD=$(substitute_osdname "$CONFIG_OSD_GENERIC" "$osdname") + + if [ -f $PID_OSD ]; then + PROCPID=`cat $PID_OSD` + if [ ! -e /proc/$PROCPID ]; then + echo "XtreemFS Object Storage Device (OSD): $osdname has crashed" + rc=1 + else + echo "XtreemFS Object Storage Device (OSD): $osdname is running" + fi + else + echo "XtreemFS Object Storage Device (OSD): $osdname is not running" + rc=3 + fi + done + + return $rc +} + +# See how we were called. +case "$1" in + start) + start "$2" + result=$? + ;; + stop) + stop "$2" + result=$? + ;; + status) + status "$2" + result=$? + ;; + reload) + result=0 + ;; + restart) + stop "$2" && sleep 1 && start "$2" + result=$? + ;; + try-restart) + ## Stop the service and if this succeeds (i.e. the + ## service was running before), start it again. + $0 status "$2" >/dev/null + if [ $? -eq 0 ]; then + $0 restart "$2" + result=$? + else + result=0 + fi + ;; + *) + echo -e "Usage: $0 {start|stop|restart|reload|status|try-restart}\n" + result=1 + ;; +esac + +exit $result diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt new file mode 100644 index 0000000..db85f26 --- /dev/null +++ b/cpp/CMakeLists.txt @@ -0,0 +1,397 @@ +cmake_minimum_required(VERSION 2.6) +PROJECT(cpp CXX C) + +#SET (CMAKE_VERBOSE_MAKEFILE true) + +# used for everything, but the preload library (which struggles with implicitly +# generated symbols suffixed with 64, e.g. open64) +set(COMPILE_DEFS "_FILE_OFFSET_BITS=64") + +# Uncomment this to enable boost::asio debug output. +#add_definitions(-DBOOST_ASIO_ENABLE_HANDLER_TRACKING) + +set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake) + +# Set variables and required libraries. +########################################## +if (CMAKE_COMPILER_IS_GNUCXX) + set(CMAKE_CXX_FLAGS "-Wall -Wno-unused-function -Wno-sign-compare -pthread") +endif(CMAKE_COMPILER_IS_GNUCXX) +if (MSVC) + # Windows uses Unicode internally, so we also use Unicode instead of the default multi-byte character set. + add_definitions(-DUNICODE -D_UNICODE) + # Require at least Windows XP. + add_definitions(-D_WIN32_WINNT=0x0501) + # autolink for boost::asio does wrongfully require date_time and regex libraries. + # See: http://www.boost.org/doc/libs/1_46_1/doc/html/boost_asio/using.html + add_definitions(-DBOOST_DATE_TIME_NO_LIB -DBOOST_REGEX_NO_LIB) + ADD_DEFINITIONS(/D _CRT_SECURE_NO_WARNINGS) +endif(MSVC) +if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS") + set (SOLARIS true) +endif(${CMAKE_SYSTEM_NAME} MATCHES "SunOS") +if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD") + set (FREEBSD true) +endif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD") + +# Set paths for required thirdparty libraries. +set(CLIENT_GOOGLE_PROTOBUF_CPP "${CMAKE_SOURCE_DIR}/thirdparty/protobuf-2.5.0") +if (WIN32) + set(CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY "${CLIENT_GOOGLE_PROTOBUF_CPP}/vsprojects/Release/libprotobuf.lib") +else() + FIND_FILE(CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY + "libprotobuf.a" + PATHS "${CLIENT_GOOGLE_PROTOBUF_CPP}/src/.libs/") + FIND_FILE(CLIENT_GOOGLE_PROTOBUF_CPP_DYNAMIC_LIBRARY + "libprotobuf.so" + PATHS "${CLIENT_GOOGLE_PROTOBUF_CPP}/src/.libs/") +endif(WIN32) +set(CLIENT_GOOGLE_TEST_CPP "${CMAKE_SOURCE_DIR}/thirdparty/gtest-1.7.0") +if (WIN32) + set(CLIENT_GOOGLE_TEST_CPP_LIBRARY "${CLIENT_GOOGLE_TEST_CPP}/msvc/gtest-md/Debug/gtestd.lib") +else() + set(CLIENT_GOOGLE_TEST_CPP_LIBRARY "${CLIENT_GOOGLE_TEST_CPP}/lib/.libs/libgtest.a") +endif(WIN32) +if (WIN32) + set(CLIENT_GOOGLE_TEST_CPP_MAIN "${CLIENT_GOOGLE_TEST_CPP}/msvc/gtest-md/Debug/gtest_main-mdd.lib") +else() + set(CLIENT_GOOGLE_TEST_CPP_MAIN "${CLIENT_GOOGLE_TEST_CPP}/lib/.libs/libgtest_main.a") +endif(WIN32) +# Windows requires for a Debug build also debug libraries from protobuf & co. +STRING(REPLACE "Release" "Debug" CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY_DEBUG ${CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY}) +STRING(REPLACE "Release" "Debug" TEMP ${CLIENT_GOOGLE_TEST_CPP_LIBRARY}) +STRING(REPLACE ".lib" "d.lib" CLIENT_GOOGLE_TEST_CPP_LIBRARY_DEBUG ${TEMP}) +STRING(REPLACE "Release" "Debug" TEMP ${CLIENT_GOOGLE_TEST_CPP_MAIN}) +STRING(REPLACE ".lib" "d.lib" CLIENT_GOOGLE_TEST_CPP_MAIN_DEBUG ${TEMP}) + +# Set required libraries. +if (NOT WIN32) + set(LIBFUSE "fuse") + SET(LIBATTR "attr") + SET(LIBPTHREAD "pthread") +endif(NOT WIN32) + +if (SOLARIS) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthreads") + SET(LIBSOCKET_SOLARIS "socket") + SET(LIBNSL_SOLARIS "nsl") + # No libattr on Solaris. + SET(LIBATTR "") +endif(SOLARIS) + +IF (APPLE OR FREEBSD) + SET(LIBATTR "") +ENDIF(APPLE OR FREEBSD) + +IF (WIN32 OR APPLE OR SOLARIS) + # Run cmake with -DBOOST_ROOT= on Windows, Solaris and MacOSX. + # We link against the boost libraries found in BOOST_ROOT. + SET(Boost_USE_STATIC_LIBS true) +ENDIF(WIN32 OR APPLE OR SOLARIS) + +IF (APPLE) + # Update 8/12/2011: Setting macosx-version-min does break mount.xtreemfs for unknown reasons - so disabled for now. + # Tell gcc to compile 10.4 compatible files (does not work otherwise on older Macs). + #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.4") + + SET(OSXFUSE_FUSE_H_INCLUDE_DIR "/usr/local/include/osxfuse/") + if (EXISTS ${OSXFUSE_FUSE_H_INCLUDE_DIR}) + include_directories(${OSXFUSE_FUSE_H_INCLUDE_DIR}) + endif(EXISTS ${OSXFUSE_FUSE_H_INCLUDE_DIR}) +ENDIF(APPLE) +IF(WIN32) + SET(Boost_USE_STATIC_LIBS true) + LINK_DIRECTORIES(${Boost_LIBRARY_DIRS}) + + SET(CBFS_LICENSE "include/cbfs/cbfs_license.h") + IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${CBFS_LICENSE}") + ## Find CbFS + # CBFS_ROOT - Input variable: Set to + # CBFS_FOUND - Output variable: CBFS was found. + # CBFS_INCLUDE_DIR - Output variable: Directory which contains the CbFS.h file. + # CBFS_LIBRARIES - Output variable: Will be set to CbFS.lib location. + find_path(CBFS_INCLUDE_DIR CbFS.h PATHS "$ENV{ProgramFiles}/EldoS/Callback File System/CPP/VC2010/32bit/dynamic_runtime(MD)" ${CBFS_ROOT}) + find_library(CBFS_LIBRARY CbFS "$ENV{ProgramFiles}/EldoS/Callback File System/CPP/VC2010/32bit/dynamic_runtime(MD)" ${CBFS_ROOT}) + + include(FindPackageHandleStandardArgs) + FIND_PACKAGE_HANDLE_STANDARD_ARGS(CBFS DEFAULT_MSG CBFS_LIBRARY CBFS_INCLUDE_DIR) + + if (CBFS_FOUND) + set(CBFS_LIBRARIES ${CBFS_LIBRARY}) + include_directories(${CBFS_INCLUDE_DIR}) + else(CBFS_FOUND) + message(FATAL_ERROR "The required library 'CbFS' was not found.") + endif (CBFS_FOUND) + mark_as_advanced(CBFS_LIBRARY) + ELSE() + message(STATUS "File ${CBFS_LICENSE} was not found. Compilation of the CbFSAdapter, which allows to mount XtreemFS volumes as network drive, will be skipped.\n\nPlease note: it is not possible to build the CbFSAdapter on your own unless you have a license for the CbFS library. The XtreemFS open-source project was granted a non-commercial license and therefore we can compile the CbFSAdapter and distribute binaries of it.\n") + ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${CBFS_LICENSE}") +ENDIF(WIN32) + +# Set required thirdparty libraries. + +# Boost +#set(Boost_DEBUG ON) +set(REQUIRED_BOOST_LIBRARIES "system" "thread" "program_options" "regex") +if (BOOST_ROOT) + message(STATUS "Info: BOOST_ROOT is set to: ${BOOST_ROOT}") +endif(BOOST_ROOT) +# Finding the boost libraries may fail. If existing, we point FIND_PACKAGE to /usr/lib64. +if(NOT BOOST_ROOT AND EXISTS "/usr/lib64/libboost_system.so") + set(BOOST_LIBRARYDIR "/usr/lib64") +endif(NOT BOOST_ROOT AND EXISTS "/usr/lib64/libboost_system.so") +# Initial find boost only to retrieve the version number. +FIND_PACKAGE(Boost) +# Unset the Boost_FOUND variable because the result of the second find will be checked. +set(Boost_FOUND) +if(WIN32 AND Boost_VERSION VERSION_GREATER "104900") + set(REQUIRED_BOOST_LIBRARIES ${REQUIRED_BOOST_LIBRARIES} "chrono") +endif(WIN32 AND Boost_VERSION VERSION_GREATER "104900") +# Actual find boost including all required libraries. +FIND_PACKAGE(Boost COMPONENTS ${REQUIRED_BOOST_LIBRARIES} REQUIRED) +if (NOT Boost_FOUND) + message(FATAL_ERROR "The boost library was not found on your system. If needed, you can also download and compile it on your own. After compiling boost locally, set the the environment variable BOOST_ROOT to the boost base directory before executing 'make' e.g., 'export BOOST_ROOT=/Users/xyz/boost_1_47_0'.") +endif(NOT Boost_FOUND) +include_directories(${Boost_INCLUDE_DIRS}) + +find_package(OpenSSL) +if (NOT OPENSSL_FOUND) +# OpenSSL find_package script cannot cope with /usr/lib64 directory under Cmake 2.8.3. + set(LIBCRYPTO "crypto") + set(LIBSSL "ssl") + set(OPENSSL_LIBRARIES ${LIBCRYPTO} ${LIBSSL}) +endif(NOT OPENSSL_FOUND) +include_directories(${OPENSSL_INCLUDE_DIR}) +# Comment this definition if the XtreemFS source should not depend on OpenSSL. +add_definitions(-DHAS_OPENSSL) + +find_package(Valgrind) +if (VALGRIND_FOUND) + include_directories(${VALGRIND_INCLUDE_DIR}) + add_definitions(-DHAS_VALGRIND) +else (VALGRIND_FOUND) + message(WARNING "Valgrind headers not found, running memcheck might report false positives.") +endif (VALGRIND_FOUND) + +SET(REQUIRED_STATIC_LIBRARIES ${CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY}) +if(BUILD_CLIENT_TESTS) + SET(REQUIRED_STATIC_LIBRARIES ${REQUIRED_STATIC_LIBRARIES} ${CLIENT_GOOGLE_TEST_CPP_LIBRARY} ${CLIENT_GOOGLE_TEST_CPP_MAIN}) +endif(BUILD_CLIENT_TESTS) + +foreach (STATIC_LIB_FULL_PATH ${REQUIRED_STATIC_LIBRARIES}) + if(NOT EXISTS ${STATIC_LIB_FULL_PATH}) + message(FATAL_ERROR "The file ${STATIC_LIB_FULL_PATH} was not found. Please run 'make client' or 'make' from the base directory in order to build the required static libraries.") + endif() +endforeach(STATIC_LIB_FULL_PATH) + +CMAKE_POLICY(SET CMP0003 OLD) +ADD_LIBRARY(protobuf STATIC IMPORTED) +ADD_LIBRARY(protobuf_debug STATIC IMPORTED) +SET_PROPERTY(TARGET protobuf PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY}) +SET_PROPERTY(TARGET protobuf_debug PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY_DEBUG}) +include_directories(${CLIENT_GOOGLE_PROTOBUF_CPP}/src) + +ADD_LIBRARY(gtest STATIC IMPORTED) +ADD_LIBRARY(gtest_debug STATIC IMPORTED) +ADD_LIBRARY(gtest_main STATIC IMPORTED) +ADD_LIBRARY(gtest_main_debug STATIC IMPORTED) +SET_PROPERTY(TARGET gtest PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_TEST_CPP_LIBRARY}) +SET_PROPERTY(TARGET gtest_debug PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_TEST_CPP_LIBRARY_DEBUG}) +SET_PROPERTY(TARGET gtest_main PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_TEST_CPP_MAIN}) +SET_PROPERTY(TARGET gtest_main_debug PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_TEST_CPP_MAIN_DEBUG}) +include_directories(${CLIENT_GOOGLE_TEST_CPP}/include) + +# Check if this is a 64 Bit system +if(UNIX AND NOT WIN32) + if(APPLE) + set(LIBFUSE "osxfuse") + endif(APPLE) +endif(UNIX AND NOT WIN32) + +SET(REQUIRED_LIBRARIES ${LIBATTR} ${LIBCRYPTO} ${LIBSSL} ${LIBPTHREAD}) +if (SKIP_FUSE) + MESSAGE(STATUS "INFO: Skipping the XtreemFS Fuse Adapter (mount.xtreemfs) because SKIP_FUSE was defined.") +else() + SET(REQUIRED_LIBRARIES ${REQUIRED_LIBRARIES} ${LIBFUSE}) +endif(SKIP_FUSE) + +foreach(LIB ${REQUIRED_LIBRARIES}) + #message(STATUS "checking for library: ${LIB}") + # For unknown reasons, setting "FIND_LIBRARY_USE_LIB64_PATHS" does not fix the issue that libraries in /usr/lib64/ are not found under openSuse. + # Therefore we just specify a list of possible library directories. + find_library(FOUND${LIB} ${LIB} PATHS "/lib64" "/usr/lib64") + if (NOT FOUND${LIB}) + if (${LIB} STREQUAL ${LIBFUSE}) + message(STATUS "INFO: If you want to skip the compilation of the FuseAdapter e.g., because your system does not provide Fuse (library: ${LIBFUSE}), please define SKIP_FUSE e.g., run: SKIP_FUSE=true make client") + endif (${LIB} STREQUAL ${LIBFUSE}) + message(FATAL_ERROR "The required library '${LIB}' was not found. Please install it on your system first.") + #else() + # message(STATUS "Result of find_library: ${FOUND${LIB}}") + endif(NOT FOUND${LIB}) +endforeach(LIB) + +# Define building of binaries. +########################################## +MESSAGE(STATUS "Configuring XtreemFS Client Library (libxtreemfs) and Volume Tools ({mkfs,rmfs,lsfs}.xtreemfs).") + +INCLUDE_DIRECTORIES(include generated) +file(GLOB_RECURSE SRCS_RPC src/rpc/*.cpp include/rpc/*.h) +file(GLOB_RECURSE SRCS_UTIL src/util/*.cpp include/util/*.h) +file(GLOB_RECURSE SRCS_GENERATED generated/*.cc generated/*.h) +file(GLOB_RECURSE SRCS_XTREEMFS src/libxtreemfs/*.cpp include/libxtreemfs/*.h) +add_library(xtreemfs ${SRCS_RPC} ${SRCS_UTIL} ${SRCS_GENERATED} ${SRCS_XTREEMFS}) +# WARNING: The resulting static libxtreemfs does NOT contain the required static library protobuf. +# If you want to use a static libxtreemfs, you have to use a CMake file like this which does automatically add the static libxtreemfs and libprotobuf to the executable. +# An alternative would be to change this file in such a way that the static libxtreemfs and libprotobuf are merged together into a static libxtreemfs. +# But this would require additional CMake macros as presented here: http://www.mail-archive.com/cmake@cmake.org/msg28670.html +TARGET_LINK_LIBRARIES(xtreemfs optimized protobuf debug protobuf_debug ${Boost_LIBRARIES} ${LIBPTHREAD} ${OPENSSL_LIBRARIES} ${LIBSOCKET_SOLARIS} ${LIBNSL_SOLARIS}) + +ADD_EXECUTABLE(example_libxtreemfs src/example_libxtreemfs/example_libxtreemfs.cpp) +SET_TARGET_PROPERTIES(example_libxtreemfs PROPERTIES COMPILE_DEFINITIONS ${COMPILE_DEFS}) +TARGET_LINK_LIBRARIES(example_libxtreemfs xtreemfs) + +ADD_EXECUTABLE(example_replication src/example_libxtreemfs/example_replication.cpp) +SET_TARGET_PROPERTIES(example_replication PROPERTIES COMPILE_DEFINITIONS ${COMPILE_DEFS}) +TARGET_LINK_LIBRARIES(example_replication xtreemfs) + +file(GLOB_RECURSE SRCS_MKFS src/mkfs.xtreemfs/*.cpp) +ADD_EXECUTABLE(mkfs.xtreemfs ${SRCS_MKFS}) +SET_TARGET_PROPERTIES(mkfs.xtreemfs PROPERTIES COMPILE_DEFINITIONS ${COMPILE_DEFS}) +TARGET_LINK_LIBRARIES(mkfs.xtreemfs xtreemfs) + +file(GLOB_RECURSE SRCS_RMFS src/rmfs.xtreemfs/*.cpp) +ADD_EXECUTABLE(rmfs.xtreemfs ${SRCS_RMFS}) +SET_TARGET_PROPERTIES(rmfs.xtreemfs PROPERTIES COMPILE_DEFINITIONS ${COMPILE_DEFS}) +TARGET_LINK_LIBRARIES(rmfs.xtreemfs xtreemfs) + +file(GLOB_RECURSE SRCS_LSFS src/lsfs.xtreemfs/*.cpp) +ADD_EXECUTABLE(lsfs.xtreemfs ${SRCS_LSFS}) +SET_TARGET_PROPERTIES(lsfs.xtreemfs PROPERTIES COMPILE_DEFINITIONS ${COMPILE_DEFS}) +TARGET_LINK_LIBRARIES(lsfs.xtreemfs xtreemfs) + +file(GLOB_RECURSE SRCS_XTFS_UTIL src/xtfsutil/xtfsutil_server.cpp) +file(GLOB_RECURSE SRCS_JSONCPP src/json/*.cpp) + +if (NOT WIN32) + if (FOUND${LIBFUSE}) + MESSAGE(STATUS "Configuring XtreemFS Fuse Adapter (mount.xtreemfs).") + file(GLOB_RECURSE SRCS_FUSE_ADAPTER src/fuse/fuse*.cpp) + file(GLOB_RECURSE SRCS_FUSE_ADAPTER_MAIN src/fuse/mount.xtreemfs.cpp) + ADD_EXECUTABLE(mount.xtreemfs ${SRCS_FUSE_ADAPTER} ${SRCS_FUSE_ADAPTER_MAIN} ${SRCS_XTFS_UTIL} ${SRCS_JSONCPP}) + SET_TARGET_PROPERTIES(mount.xtreemfs PROPERTIES COMPILE_DEFINITIONS ${COMPILE_DEFS}) + TARGET_LINK_LIBRARIES(mount.xtreemfs xtreemfs ${LIBFUSE}) + + set(UNITTESTS_REQUIRED_SOURCES_fuse ${SRCS_FUSE_ADAPTER} ${SRCS_XTFS_UTIL} ${SRCS_JSONCPP}) + set(UNITTESTS_REQUIRED_LIBRARIES_fuse ${LIBFUSE}) + endif(FOUND${LIBFUSE}) + + ADD_EXECUTABLE(xtfsutil src/xtfsutil/xtfsutil.cpp ${SRCS_JSONCPP}) + TARGET_LINK_LIBRARIES(xtfsutil ${Boost_LIBRARIES} ${LIBATTR}) + + set(UNITTESTS_SKIP_cbfs true) +endif(NOT WIN32) +if(WIN32 AND CBFS_FOUND) + MESSAGE(STATUS "Configuring XtreemFS CbFS Adapter (mount.xtreemfs.exe).") + file(GLOB_RECURSE SRCS_CBFS_ADAPTER src/cbfs/*.cpp) + ADD_EXECUTABLE(mount.xtreemfs ${SRCS_CBFS_ADAPTER} ${SRCS_XTFS_UTIL} ${SRCS_JSONCPP}) + TARGET_LINK_LIBRARIES(mount.xtreemfs xtreemfs ${CBFS_LIBRARIES}) + + set(UNITTESTS_SKIP_fuse true) +endif(WIN32 AND CBFS_FOUND) + +function(find_source_files RESULT) + set(RESULT "") + foreach(GLOBEXPR ${ARGV}) + file(GLOB_RECURSE FILES ${GLOBEXPR}) + foreach(TEST ${FILES}) + get_filename_component(DIRNAME ${TEST} PATH) + get_filename_component(COMPONENT ${DIRNAME} NAME) + get_filename_component(FILENAME ${TEST} NAME) + if (${FILENAME} MATCHES "_test.cpp$") + #skip + elseif (${FILENAME} MATCHES "_main.cpp$") + #skip + else() + LIST(APPEND RESULT ${TEST}) + endif() + endforeach(TEST) + endforeach(GLOBEXPR) + set(FIND_RESULT ${RESULT} PARENT_SCOPE) +endfunction(find_source_files) + +#SET(BUILD_PRELOAD TRUE) +if (BUILD_PRELOAD) + find_source_files("src/ld_preload/*.cpp" "include/ld_preload/*.h") + set(SRCS_PRELOAD ${FIND_RESULT}) + + # The LD_PRELOAD dynamic library + add_library(xtreemfs_preload SHARED ${SRCS_PRELOAD} + ${SRCS_RPC} ${SRCS_UTIL} ${SRCS_GENERATED} ${SRCS_XTREEMFS}) + + IF(NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug") + SET_TARGET_PROPERTIES(xtreemfs_preload PROPERTIES COMPILE_DEFINITIONS "XTREEMFS_PRELOAD_QUIET") + ENDIF(NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug") + + SET_TARGET_PROPERTIES(xtreemfs_preload PROPERTIES LINKER_LANGUAGE C) + TARGET_LINK_LIBRARIES(xtreemfs_preload + xtreemfs + -ldl + ${CLIENT_GOOGLE_PROTOBUF_CPP_DYNAMIC_LIBRARY}) + ADD_EXECUTABLE(preload_test "test/ld_preload/preload_test.cpp") +endif(BUILD_PRELOAD) + +################################################################################ +# Define building of unittests. +################################################################################ +# +# Unit tests are only compiled if the CMake variable BUILD_CLIENT_TESTS is set +# (passed by the top level Makefile if the environment variable +# BUILD_CLIENT_TESTS is set). +# +# The directory structure under test/ is identical to the one under src/ and +# include/. +# Since some components are not available on all plattforms, some variables +# are inspected for each component before the component's unit tests are +# compiled. +# A component here is given by the name of the directory below test/ i.e., +# the component for the file test/fuse/fuse_options_test.cpp is "fuse". +# +# The following variables are inspected for each component: +# UNITTESTS_SKIP_${COMPONENT} - set if component unit tests must not be compiled +# UNITTESTS_REQUIRED_SOURCES_${COMPONENT} - list of source files which have to +# be compiled for the unit test +# UNITTESTS_REQUIRED_LIBRARIES_${COMPONENT} - list of libraries which have to be +# linked to the unit test. +################################################################################ +if(BUILD_CLIENT_TESTS) + # enable_testing() will provide a target "test". + enable_testing() + include_directories("test") + + MESSAGE(STATUS "Configuring libxtreemfs unittests.") + + file(GLOB_RECURSE SRCS_TEST_COMMON test/common/*.cpp) + add_library(test_common ${SRCS_TEST_COMMON}) + set (UNITTESTS_SKIP_common true) + + file(GLOB_RECURSE SRCS_TESTS test/*.cpp) + foreach (TEST ${SRCS_TESTS}) + get_filename_component(DIRNAME ${TEST} PATH) + get_filename_component(COMPONENT ${DIRNAME} NAME) + get_filename_component(FILENAME ${TEST} NAME) + if (NOT UNITTESTS_SKIP_${COMPONENT}) + if (${FILENAME} MATCHES "_test.cpp$") + string(REGEX REPLACE "_test.cpp$" "" testname ${FILENAME}) + set(testname "test_${testname}") + MESSAGE(STATUS "\tConfiguring test: ${testname}.") + + add_executable(${testname} ${TEST} ${UNITTESTS_REQUIRED_SOURCES_${COMPONENT}}) + SET_TARGET_PROPERTIES(${testname} PROPERTIES COMPILE_DEFINITIONS ${COMPILE_DEFS}) + TARGET_LINK_LIBRARIES(${testname} gtest_main gtest test_common xtreemfs ${UNITTESTS_REQUIRED_LIBRARIES_${COMPONENT}}) + ADD_TEST(${testname} ${testname}) + else() + MESSAGE(STATUS "\tWARNING: Found file '${FILENAME}' below test/ does not end with '_test.cpp' and was therefore ignored as unit test.") + endif(${FILENAME} MATCHES "_test.cpp$") + endif(NOT UNITTESTS_SKIP_${COMPONENT}) + endforeach(TEST) +endif(BUILD_CLIENT_TESTS) diff --git a/cpp/Doxyfile b/cpp/Doxyfile new file mode 100644 index 0000000..07fd28c --- /dev/null +++ b/cpp/Doxyfile @@ -0,0 +1,1623 @@ +# Doxyfile 1.7.1 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# http://www.gnu.org/software/libiconv for the list of possible encodings. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = XtreemFS-Client + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, +# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, +# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English +# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, +# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, +# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like regular Qt-style comments +# (thus requiring an explicit @brief command for a brief description.) + +JAVADOC_AUTOBRIEF = YES + +# If the QT_AUTOBRIEF tag is set to YES then Doxygen will +# interpret the first line (until the first dot) of a Qt-style +# comment as the brief description. If set to NO, the comments +# will behave just like regular Qt-style comments (thus requiring +# an explicit \brief command for a brief description.) + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java +# sources only. Doxygen will then generate output that is more tailored for +# Java. For instance, namespaces will be presented as packages, qualified +# scopes will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources only. Doxygen will then generate output that is more tailored for +# Fortran. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for +# VHDL. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given extension. +# Doxygen has a built-in mapping, but you can override or extend it using this +# tag. The format is ext=language, where ext is a file extension, and language +# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C, +# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make +# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C +# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions +# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should +# set this tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. +# func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. +# Doxygen will parse them like normal C++ but will assume all classes use public +# instead of private inheritance when no explicit protection keyword is present. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate getter +# and setter methods for a property. Setting this option to YES (the default) +# will make doxygen to replace the get and set methods by a property in the +# documentation. This will only work if the methods are indeed getting or +# setting a simple type. If this is not the case, or you want to show the +# methods anyway, you should set this option to NO. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum +# is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically +# be useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. + +TYPEDEF_HIDES_STRUCT = NO + +# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to +# determine which symbols to keep in memory and which to flush to disk. +# When the cache is full, less often used symbols will be written to disk. +# For small to medium size projects (<1000 input files) the default value is +# probably good enough. For larger projects a too small cache size can cause +# doxygen to be busy swapping symbols to and from disk most of the time +# causing a significant performance penality. +# If the system has enough physical memory increasing the cache will improve the +# performance by keeping more symbols in memory. Note that the value works on +# a logarithmic scale so increasing the size by one will rougly double the +# memory usage. The cache size is given by this formula: +# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, +# corresponding to a cache size of 2^16 = 65536 symbols + +SYMBOL_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base +# name of the file that contains the anonymous namespace. By default +# anonymous namespace are hidden. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen +# will list include files with double quotes in the documentation +# rather than with sharp brackets. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen +# will sort the (brief and detailed) documentation of class members so that +# constructors and destructors are listed first. If set to NO (the default) +# the constructors will appear in the respective orders defined by +# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. +# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO +# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the +# hierarchy of group names into alphabetical order. If set to NO (the default) +# the group names will appear in their defined order. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. The default is NO. + +SHOW_DIRECTORIES = NO + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. +# This will remove the Files entry from the Quick Index and from the +# Folder Tree View (if specified). The default is YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the +# Namespaces page. This will remove the Namespaces entry from the Quick Index +# and from the Folder Tree View (if specified). The default is YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the program writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. The create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. +# You can optionally specify a file name after the option, if omitted +# DoxygenLayout.xml will be used as the name of the layout file. + +LAYOUT_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = src \ + include \ + test + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is +# also the default input encoding. Doxygen uses libiconv (or the iconv built +# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for +# the list of possible encodings. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. Note that the wildcards are matched +# against the file with absolute path, so to exclude all test directories +# for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) +# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from +# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will +# link to the source code. Otherwise they will link to the documentation. + +REFERENCES_LINK_SOURCE = YES + +# If the USE_HTAGS tag is set to YES then the references to source code +# will point to the HTML generated by the htags(1) tool instead of doxygen +# built-in source browser. The htags tool is part of GNU's global source +# tagging system (see http://www.gnu.org/software/global/global.html). You +# will need version 4.8.6 or higher. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = YES + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. +# Doxygen will adjust the colors in the stylesheet and background images +# according to this color. Hue is specified as an angle on a colorwheel, +# see http://en.wikipedia.org/wiki/Hue for more information. +# For instance the value 0 represents red, 60 is yellow, 120 is green, +# 180 is cyan, 240 is blue, 300 purple, and 360 is red again. +# The allowed range is 0 to 359. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of +# the colors in the HTML output. For a value of 0 the output will use +# grayscales only. A value of 255 will produce the most vivid colors. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to +# the luminance component of the colors in the HTML output. Values below +# 100 gradually make the output lighter, whereas values above 100 make +# the output darker. The value divided by 100 is the actual gamma applied, +# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2, +# and 100 does not change the gamma. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting +# this to NO can help when comparing the output of multiple runs. + +HTML_TIMESTAMP = YES + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. For this to work a browser that supports +# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox +# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). + +HTML_DYNAMIC_SECTIONS = NO + +# If the GENERATE_DOCSET tag is set to YES, additional index files +# will be generated that can be used as input for Apple's Xcode 3 +# integrated development environment, introduced with OSX 10.5 (Leopard). +# To create a documentation set, doxygen will generate a Makefile in the +# HTML output directory. Running make will produce the docset in that +# directory and running "make install" will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find +# it at startup. +# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. + +GENERATE_DOCSET = NO + +# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the +# feed. A documentation feed provides an umbrella under which multiple +# documentation sets from a single provider (such as a company or product suite) +# can be grouped. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that +# should uniquely identify the documentation set bundle. This should be a +# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen +# will append .docset to the name. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING +# is used to encode HtmlHelp index (hhk), content (hhc) and project file +# content. + +CHM_INDEX_ENCODING = + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated +# that can be used as input for Qt's qhelpgenerator to generate a +# Qt Compressed Help (.qch) of the generated HTML documentation. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can +# be used to specify the file name of the resulting .qch file. +# The path specified is relative to the HTML output folder. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating +# Qt Help Project output. For more information please see +# http://doc.trolltech.com/qthelpproject.html#namespace + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating +# Qt Help Project output. For more information please see +# http://doc.trolltech.com/qthelpproject.html#virtual-folders + +QHP_VIRTUAL_FOLDER = doc + +# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to +# add. For more information please see +# http://doc.trolltech.com/qthelpproject.html#custom-filters + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see +# +# Qt Help Project / Custom Filters. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's +# filter section matches. +# +# Qt Help Project / Filter Attributes. + +QHP_SECT_FILTER_ATTRS = + +# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can +# be used to specify the location of Qt's qhelpgenerator. +# If non-empty doxygen will try to run qhelpgenerator on the generated +# .qhp file. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files +# will be generated, which together with the HTML files, form an Eclipse help +# plugin. To install this plugin and make it available under the help contents +# menu in Eclipse, the contents of the directory containing the HTML and XML +# files needs to be copied into the plugins directory of eclipse. The name of +# the directory within the plugins directory should be the same as +# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before +# the help appears. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have +# this name. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. +# If the tag value is set to YES, a side panel will be generated +# containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser). +# Windows users are probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories, +# and Class Hierarchy pages using a tree view instead of an ordered list. + +USE_INLINE_TREES = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open +# links to external symbols imported via tag files in a separate window. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of Latex formulas included +# as images in the HTML documentation. The default is 10. Note that +# when you change the font size after a successful doxygen run you need +# to manually remove any form_*.png images from the HTML output directory +# to force them to be regenerated. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are +# not supported properly for IE 6.0, but are supported on all modern browsers. +# Note that when changing this option you need to delete any form_*.png files +# in the HTML output before the changes have effect. + +FORMULA_TRANSPARENT = YES + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box +# for the HTML output. The underlying search engine uses javascript +# and DHTML and should work on any modern browser. Note that when using +# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets +# (GENERATE_DOCSET) there is already a search function so this one should +# typically be disabled. For large projects the javascript based search engine +# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution. + +SEARCHENGINE = YES + +# When the SERVER_BASED_SEARCH tag is enabled the search engine will be +# implemented using a PHP enabled web server instead of at the web client +# using Javascript. Doxygen will generate the search PHP script and index +# file to put on the web server. The advantage of the server +# based approach is that it scales better to large projects and allows +# full text search. The disadvances is that it is more difficult to setup +# and does not have live searching capabilities. + +SERVER_BASED_SEARCH = NO + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. +# Note that when enabling USE_PDFLATEX this option is only used for +# generating bitmaps for formulas in the HTML output, but not in the +# Makefile that is written to the output directory. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +# If LATEX_SOURCE_CODE is set to YES then doxygen will include +# source code with syntax highlighting in the LaTeX output. +# Note that which sources are shown also depends on other settings +# such as SOURCE_BROWSER. + +LATEX_SOURCE_CODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. This is useful +# if you want to understand what is going on. On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_DEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = YES + +# You can define message sequence charts within doxygen comments using the \msc +# command. Doxygen will then run the mscgen tool (see +# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the +# documentation. The MSCGEN_PATH tag allows you to specify the directory where +# the mscgen tool resides. If left empty the tool is assumed to be found in the +# default search path. + +MSCGEN_PATH = + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is +# allowed to run in parallel. When set to 0 (the default) doxygen will +# base this on the number of processors available in the system. You can set it +# explicitly to a value larger than 0 to get control over the balance +# between CPU load and processing speed. + +DOT_NUM_THREADS = 0 + +# By default doxygen will write a font called FreeSans.ttf to the output +# directory and reference it in all dot files that doxygen generates. This +# font does not include all possible unicode characters however, so when you need +# these (or just want a differently looking font) you can specify the font name +# using DOT_FONTNAME. You need need to make sure dot is able to find the font, +# which can be done by putting it in a standard location or by setting the +# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory +# containing the font. + +DOT_FONTNAME = FreeSans.ttf + +# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. +# The default size is 10pt. + +DOT_FONTSIZE = 10 + +# By default doxygen will tell dot to use the output directory to look for the +# FreeSans.ttf font (which doxygen will put there itself). If you specify a +# different font using DOT_FONTNAME you can set the path where dot +# can find it using this tag. + +DOT_FONTPATH = + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = NO + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH and HAVE_DOT options are set to YES then +# doxygen will generate a call dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable call graphs +# for selected functions only using the \callgraph command. + +CALL_GRAPH = NO + +# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then +# doxygen will generate a caller dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable caller +# graphs for selected functions only using the \callergraph command. + +CALLER_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = png + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of +# nodes that will be shown in the graph. If the number of nodes in a graph +# becomes larger than this value, doxygen will truncate the graph, which is +# visualized by representing a node as a red box. Note that doxygen if the +# number of direct children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note +# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. + +DOT_GRAPH_MAX_NODES = 50 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, because dot on Windows does not +# seem to support this out of the box. Warning: Depending on the platform used, +# enabling this option may lead to badly anti-aliased labels on the edges of +# a graph (i.e. they become hard to read). + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = YES + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES diff --git a/cpp/cmake/FindValgrind.cmake b/cpp/cmake/FindValgrind.cmake new file mode 100644 index 0000000..cc21cb6 --- /dev/null +++ b/cpp/cmake/FindValgrind.cmake @@ -0,0 +1,18 @@ +find_path(VALGRIND_INCLUDE_DIR + NAMES + valgrind/valgrind.h + HINTS + /usr + /usr/local + PATH_SUFFIXES + include +) + +include(FindPackageHandleStandardArgs) + +find_package_handle_standard_args(VALGRIND + DEFAULT_MSG + VALGRIND_INCLUDE_DIR +) + +mark_as_advanced(VALGRIND_INCLUDE_DIR) \ No newline at end of file diff --git a/cpp/cpp_prj/.dep.inc b/cpp/cpp_prj/.dep.inc new file mode 100644 index 0000000..4560e55 --- /dev/null +++ b/cpp/cpp_prj/.dep.inc @@ -0,0 +1,5 @@ +# This code depends on make tool being used +DEPFILES=$(wildcard $(addsuffix .d, ${OBJECTFILES})) +ifneq (${DEPFILES},) +include ${DEPFILES} +endif diff --git a/cpp/cpp_prj/cpp_prj-Makefile.mk b/cpp/cpp_prj/cpp_prj-Makefile.mk new file mode 100644 index 0000000..ec9de69 --- /dev/null +++ b/cpp/cpp_prj/cpp_prj-Makefile.mk @@ -0,0 +1,128 @@ +# +# There exist several targets which are by default empty and which can be +# used for execution of your targets. These targets are usually executed +# before and after some main targets. They are: +# +# .build-pre: called before 'build' target +# .build-post: called after 'build' target +# .clean-pre: called before 'clean' target +# .clean-post: called after 'clean' target +# .clobber-pre: called before 'clobber' target +# .clobber-post: called after 'clobber' target +# .all-pre: called before 'all' target +# .all-post: called after 'all' target +# .help-pre: called before 'help' target +# .help-post: called after 'help' target +# +# Targets beginning with '.' are not intended to be called on their own. +# +# Main targets can be executed directly, and they are: +# +# build build a specific configuration +# clean remove built files from a configuration +# clobber remove all built files +# all build all configurations +# help print help mesage +# +# Targets .build-impl, .clean-impl, .clobber-impl, .all-impl, and +# .help-impl are implemented in nbproject/makefile-impl.mk. +# +# Available make variables: +# +# CND_BASEDIR base directory for relative paths +# CND_DISTDIR default top distribution directory (build artifacts) +# CND_BUILDDIR default top build directory (object files, ...) +# CONF name of current configuration +# CND_PLATFORM_${CONF} platform name (current configuration) +# CND_ARTIFACT_DIR_${CONF} directory of build artifact (current configuration) +# CND_ARTIFACT_NAME_${CONF} name of build artifact (current configuration) +# CND_ARTIFACT_PATH_${CONF} path to build artifact (current configuration) +# CND_PACKAGE_DIR_${CONF} directory of package (current configuration) +# CND_PACKAGE_NAME_${CONF} name of package (current configuration) +# CND_PACKAGE_PATH_${CONF} path to package (current configuration) +# +# NOCDDL + + +# Environment +MKDIR=mkdir +CP=cp +CCADMIN=CCadmin + + +# build +build: .build-post + +.build-pre: +# Add your pre 'build' code here... + +.build-post: .build-impl +# Add your post 'build' code here... + + +# clean +clean: .clean-post + +.clean-pre: +# Add your pre 'clean' code here... + +.clean-post: .clean-impl +# Add your post 'clean' code here... + + +# clobber +clobber: .clobber-post + +.clobber-pre: +# Add your pre 'clobber' code here... + +.clobber-post: .clobber-impl +# Add your post 'clobber' code here... + + +# all +all: .all-post + +.all-pre: +# Add your pre 'all' code here... + +.all-post: .all-impl +# Add your post 'all' code here... + + +# build tests +build-tests: .build-tests-post + +.build-tests-pre: +# Add your pre 'build-tests' code here... + +.build-tests-post: .build-tests-impl +# Add your post 'build-tests' code here... + + +# run tests +test: .test-post + +.test-pre: +# Add your pre 'test' code here... + +.test-post: .test-impl +# Add your post 'test' code here... + + +# help +help: .help-post + +.help-pre: +# Add your pre 'help' code here... + +.help-post: .help-impl +# Add your post 'help' code here... + + + +# include project implementation makefile +include nbproject/Makefile-impl.mk + +# include project make variables +include nbproject/Makefile-variables.mk diff --git a/cpp/cpp_prj/nbproject/Makefile-Default.mk b/cpp/cpp_prj/nbproject/Makefile-Default.mk new file mode 100644 index 0000000..f763f28 --- /dev/null +++ b/cpp/cpp_prj/nbproject/Makefile-Default.mk @@ -0,0 +1,66 @@ +# +# Generated Makefile - do not edit! +# +# Edit the Makefile in the project folder instead (../Makefile). Each target +# has a -pre and a -post target defined where you can add customized code. +# +# This makefile implements configuration specific macros and targets. + + +# Environment +MKDIR=mkdir +CP=cp +GREP=grep +NM=nm +CCADMIN=CCadmin +RANLIB=ranlib +CC=gcc +CCC=g++ +CXX=g++ +FC= +AS=as + +# Macros +CND_PLATFORM=GNU-Linux-x86 +CND_CONF=Default +CND_DISTDIR=dist + +# Include project Makefile +include cpp_prj-Makefile.mk + +# Object Directory +OBJECTDIR=build/${CND_CONF}/${CND_PLATFORM} + +# Object Files +OBJECTFILES= + + +# C Compiler Flags +CFLAGS= + +# CC Compiler Flags +CCFLAGS= +CXXFLAGS= + +# Fortran Compiler Flags +FFLAGS= + +# Assembler Flags +ASFLAGS= + +# Link Libraries and Options +LDLIBSOPTIONS= + +# Build Targets +.build-conf: ${BUILD_SUBPROJECTS} + cd .. && ${MAKE} -f Makefile + +# Subprojects +.build-subprojects: + +# Clean Targets +.clean-conf: ${CLEAN_SUBPROJECTS} + cd .. && ${MAKE} -f Makefile clean + +# Subprojects +.clean-subprojects: diff --git a/cpp/cpp_prj/nbproject/Makefile-impl.mk b/cpp/cpp_prj/nbproject/Makefile-impl.mk new file mode 100644 index 0000000..41e48c2 --- /dev/null +++ b/cpp/cpp_prj/nbproject/Makefile-impl.mk @@ -0,0 +1,133 @@ +# +# Generated Makefile - do not edit! +# +# Edit the Makefile in the project folder instead (../Makefile). Each target +# has a pre- and a post- target defined where you can add customization code. +# +# This makefile implements macros and targets common to all configurations. +# +# NOCDDL + + +# Building and Cleaning subprojects are done by default, but can be controlled with the SUB +# macro. If SUB=no, subprojects will not be built or cleaned. The following macro +# statements set BUILD_SUB-CONF and CLEAN_SUB-CONF to .build-reqprojects-conf +# and .clean-reqprojects-conf unless SUB has the value 'no' +SUB_no=NO +SUBPROJECTS=${SUB_${SUB}} +BUILD_SUBPROJECTS_=.build-subprojects +BUILD_SUBPROJECTS_NO= +BUILD_SUBPROJECTS=${BUILD_SUBPROJECTS_${SUBPROJECTS}} +CLEAN_SUBPROJECTS_=.clean-subprojects +CLEAN_SUBPROJECTS_NO= +CLEAN_SUBPROJECTS=${CLEAN_SUBPROJECTS_${SUBPROJECTS}} + + +# Project Name +PROJECTNAME=cpp_prj + +# Active Configuration +DEFAULTCONF=Default +CONF=${DEFAULTCONF} + +# All Configurations +ALLCONFS=Default + + +# build +.build-impl: .build-pre .validate-impl .depcheck-impl + @#echo "=> Running $@... Configuration=$(CONF)" + "${MAKE}" -f nbproject/Makefile-${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .build-conf + + +# clean +.clean-impl: .clean-pre .validate-impl .depcheck-impl + @#echo "=> Running $@... Configuration=$(CONF)" + "${MAKE}" -f nbproject/Makefile-${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .clean-conf + + +# clobber +.clobber-impl: .clobber-pre .depcheck-impl + @#echo "=> Running $@..." + for CONF in ${ALLCONFS}; \ + do \ + "${MAKE}" -f nbproject/Makefile-$${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .clean-conf; \ + done + +# all +.all-impl: .all-pre .depcheck-impl + @#echo "=> Running $@..." + for CONF in ${ALLCONFS}; \ + do \ + "${MAKE}" -f nbproject/Makefile-$${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .build-conf; \ + done + +# build tests +.build-tests-impl: .build-impl .build-tests-pre + @#echo "=> Running $@... Configuration=$(CONF)" + "${MAKE}" -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .build-tests-conf + +# run tests +.test-impl: .build-tests-impl .test-pre + @#echo "=> Running $@... Configuration=$(CONF)" + "${MAKE}" -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .test-conf + +# dependency checking support +.depcheck-impl: + @echo "# This code depends on make tool being used" >.dep.inc + @if [ -n "${MAKE_VERSION}" ]; then \ + echo "DEPFILES=\$$(wildcard \$$(addsuffix .d, \$${OBJECTFILES}))" >>.dep.inc; \ + echo "ifneq (\$${DEPFILES},)" >>.dep.inc; \ + echo "include \$${DEPFILES}" >>.dep.inc; \ + echo "endif" >>.dep.inc; \ + else \ + echo ".KEEP_STATE:" >>.dep.inc; \ + echo ".KEEP_STATE_FILE:.make.state.\$${CONF}" >>.dep.inc; \ + fi + +# configuration validation +.validate-impl: + @if [ ! -f nbproject/Makefile-${CONF}.mk ]; \ + then \ + echo ""; \ + echo "Error: can not find the makefile for configuration '${CONF}' in project ${PROJECTNAME}"; \ + echo "See 'make help' for details."; \ + echo "Current directory: " `pwd`; \ + echo ""; \ + fi + @if [ ! -f nbproject/Makefile-${CONF}.mk ]; \ + then \ + exit 1; \ + fi + + +# help +.help-impl: .help-pre + @echo "This makefile supports the following configurations:" + @echo " ${ALLCONFS}" + @echo "" + @echo "and the following targets:" + @echo " build (default target)" + @echo " clean" + @echo " clobber" + @echo " all" + @echo " help" + @echo "" + @echo "Makefile Usage:" + @echo " make [CONF=] [SUB=no] build" + @echo " make [CONF=] [SUB=no] clean" + @echo " make [SUB=no] clobber" + @echo " make [SUB=no] all" + @echo " make help" + @echo "" + @echo "Target 'build' will build a specific configuration and, unless 'SUB=no'," + @echo " also build subprojects." + @echo "Target 'clean' will clean a specific configuration and, unless 'SUB=no'," + @echo " also clean subprojects." + @echo "Target 'clobber' will remove all built files from all configurations and," + @echo " unless 'SUB=no', also from subprojects." + @echo "Target 'all' will will build all configurations and, unless 'SUB=no'," + @echo " also build subprojects." + @echo "Target 'help' prints this message." + @echo "" + diff --git a/cpp/cpp_prj/nbproject/Makefile-variables.mk b/cpp/cpp_prj/nbproject/Makefile-variables.mk new file mode 100644 index 0000000..1dd487f --- /dev/null +++ b/cpp/cpp_prj/nbproject/Makefile-variables.mk @@ -0,0 +1,16 @@ +# +# Generated - do not edit! +# +# NOCDDL +# +CND_BASEDIR=`pwd` +CND_BUILDDIR=build +CND_DISTDIR=dist +# Default configuration +CND_PLATFORM_Default=GNU-Linux-x86 +CND_ARTIFACT_DIR_Default=.. +CND_ARTIFACT_NAME_Default=fusetest +CND_ARTIFACT_PATH_Default=../fusetest +CND_PACKAGE_DIR_Default=dist/Default/GNU-Linux-x86/package +CND_PACKAGE_NAME_Default=cppprj.tar +CND_PACKAGE_PATH_Default=dist/Default/GNU-Linux-x86/package/cppprj.tar diff --git a/cpp/cpp_prj/nbproject/Package-Default.bash b/cpp/cpp_prj/nbproject/Package-Default.bash new file mode 100644 index 0000000..d994f75 --- /dev/null +++ b/cpp/cpp_prj/nbproject/Package-Default.bash @@ -0,0 +1,74 @@ +#!/bin/bash -x + +# +# Generated - do not edit! +# + +# Macros +TOP=`pwd` +CND_PLATFORM=GNU-Linux-x86 +CND_CONF=Default +CND_DISTDIR=dist +NBTMPDIR=build/${CND_CONF}/${CND_PLATFORM}/tmp-packaging +TMPDIRNAME=tmp-packaging +OUTPUT_PATH=../fusetest +OUTPUT_BASENAME=fusetest +PACKAGE_TOP_DIR=cppprj/ + +# Functions +function checkReturnCode +{ + rc=$? + if [ $rc != 0 ] + then + exit $rc + fi +} +function makeDirectory +# $1 directory path +# $2 permission (optional) +{ + mkdir -p "$1" + checkReturnCode + if [ "$2" != "" ] + then + chmod $2 "$1" + checkReturnCode + fi +} +function copyFileToTmpDir +# $1 from-file path +# $2 to-file path +# $3 permission +{ + cp "$1" "$2" + checkReturnCode + if [ "$3" != "" ] + then + chmod $3 "$2" + checkReturnCode + fi +} + +# Setup +cd "${TOP}" +mkdir -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package +rm -rf ${NBTMPDIR} +mkdir -p ${NBTMPDIR} + +# Copy files and create directories and links +cd "${TOP}" +makeDirectory "${NBTMPDIR}/cppprj/bin" +copyFileToTmpDir "${OUTPUT_PATH}" "${NBTMPDIR}/${PACKAGE_TOP_DIR}bin/${OUTPUT_BASENAME}" 0755 + + +# Generate tar file +cd "${TOP}" +rm -f ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/cppprj.tar +cd ${NBTMPDIR} +tar -vcf ../../../../${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/cppprj.tar * +checkReturnCode + +# Cleanup +cd "${TOP}" +rm -rf ${NBTMPDIR} diff --git a/cpp/cpp_prj/nbproject/configurations.xml b/cpp/cpp_prj/nbproject/configurations.xml new file mode 100644 index 0000000..28dce16 --- /dev/null +++ b/cpp/cpp_prj/nbproject/configurations.xml @@ -0,0 +1,137 @@ + + + + + + Common.pb.cc + Common.pb.h + PBRPC.pb.cc + PBRPC.pb.h + + + Ping.pb.cc + Ping.pb.h + PingServiceClient.h + RPC.pb.cc + RPC.pb.h + + + DIR.pb.cc + DIR.pb.h + DIRServiceClient.h + GlobalTypes.pb.cc + GlobalTypes.pb.h + MRC.pb.cc + MRC.pb.h + MRCServiceClient.h + OSD.pb.cc + OSD.pb.h + OSDServiceClient.h + + + + + abstract_socket_channel.h + callback_interface.h + client.h + client_connection.h + client_request.h + client_request_callback_interface.h + grid_ssl_socket_channel.h + record_marker.h + ssl_options.h + ssl_socket_channel.h + sync_callback.h + tcp_socket_channel.h + + + logging.h + pbrpc_url.h + user_mapping.h + + + + + fuse_client.cpp + mkvol_xtreemfs.cpp + + + client.cpp + client_connection.cpp + client_request.cpp + record_marker.cpp + + + logging.cpp + pbrpc_url.cpp + user_mapping.cpp + + main.cpp + + + ../CMakeLists.txt + ../Makefile + cpp_prj-Makefile.mk + + + + ../src + ../generated + ../include + + cpp_prj-Makefile.mk + + + + localhost + GNU|GNU + 2 + + + + .. + ${MAKE} -f Makefile + ${MAKE} -f Makefile clean + ../fusetest + + + ../generated + ../include + + + + + + + + ../generated + + + + + + + ../generated + + + + + + + ../generated + + + + + + + ../include/rpc + + + + + + diff --git a/cpp/cpp_prj/nbproject/private/configurations.xml b/cpp/cpp_prj/nbproject/private/configurations.xml new file mode 100644 index 0000000..3a36d13 --- /dev/null +++ b/cpp/cpp_prj/nbproject/private/configurations.xml @@ -0,0 +1,21 @@ + + + cpp_prj-Makefile.mk + 0 + + + + + + /home/bjko/mnt + + true + 0 + 0 + 0 + + + + + + diff --git a/cpp/cpp_prj/nbproject/private/private.properties b/cpp/cpp_prj/nbproject/private/private.properties new file mode 100644 index 0000000..e69de29 diff --git a/cpp/cpp_prj/nbproject/private/private.xml b/cpp/cpp_prj/nbproject/private/private.xml new file mode 100644 index 0000000..bf91c93 --- /dev/null +++ b/cpp/cpp_prj/nbproject/private/private.xml @@ -0,0 +1,7 @@ + + + + true + + + diff --git a/cpp/cpp_prj/nbproject/project.properties b/cpp/cpp_prj/nbproject/project.properties new file mode 100644 index 0000000..e69de29 diff --git a/cpp/cpp_prj/nbproject/project.xml b/cpp/cpp_prj/nbproject/project.xml new file mode 100644 index 0000000..fa8dde0 --- /dev/null +++ b/cpp/cpp_prj/nbproject/project.xml @@ -0,0 +1,23 @@ + + + org.netbeans.modules.cnd.makeproject + + + cpp_prj + 0 + + cc,cpp + h + UTF-8 + + + ../src + ../generated + ../include + + + Default + + + + diff --git a/cpp/generated/include/Common.pb.cc b/cpp/generated/include/Common.pb.cc new file mode 100644 index 0000000..f2b1cec --- /dev/null +++ b/cpp/generated/include/Common.pb.cc @@ -0,0 +1,438 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: include/Common.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "include/Common.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +namespace { + +const ::google::protobuf::Descriptor* emptyRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + emptyRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* emptyResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + emptyResponse_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_include_2fCommon_2eproto() { + protobuf_AddDesc_include_2fCommon_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "include/Common.proto"); + GOOGLE_CHECK(file != NULL); + emptyRequest_descriptor_ = file->message_type(0); + static const int emptyRequest_offsets_[1] = { + }; + emptyRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + emptyRequest_descriptor_, + emptyRequest::default_instance_, + emptyRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(emptyRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(emptyRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(emptyRequest)); + emptyResponse_descriptor_ = file->message_type(1); + static const int emptyResponse_offsets_[1] = { + }; + emptyResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + emptyResponse_descriptor_, + emptyResponse::default_instance_, + emptyResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(emptyResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(emptyResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(emptyResponse)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_include_2fCommon_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + emptyRequest_descriptor_, &emptyRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + emptyResponse_descriptor_, &emptyResponse::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_include_2fCommon_2eproto() { + delete emptyRequest::default_instance_; + delete emptyRequest_reflection_; + delete emptyResponse::default_instance_; + delete emptyResponse_reflection_; +} + +void protobuf_AddDesc_include_2fCommon_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\024include/Common.proto\022\016xtreemfs.pbrpc\"\016" + "\n\014emptyRequest\"\017\n\remptyResponseB(\n&org.x" + "treemfs.pbrpc.generatedinterfaces", 113); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "include/Common.proto", &protobuf_RegisterTypes); + emptyRequest::default_instance_ = new emptyRequest(); + emptyResponse::default_instance_ = new emptyResponse(); + emptyRequest::default_instance_->InitAsDefaultInstance(); + emptyResponse::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_include_2fCommon_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_include_2fCommon_2eproto { + StaticDescriptorInitializer_include_2fCommon_2eproto() { + protobuf_AddDesc_include_2fCommon_2eproto(); + } +} static_descriptor_initializer_include_2fCommon_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +emptyRequest::emptyRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void emptyRequest::InitAsDefaultInstance() { +} + +emptyRequest::emptyRequest(const emptyRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void emptyRequest::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +emptyRequest::~emptyRequest() { + SharedDtor(); +} + +void emptyRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void emptyRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* emptyRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return emptyRequest_descriptor_; +} + +const emptyRequest& emptyRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_include_2fCommon_2eproto(); + return *default_instance_; +} + +emptyRequest* emptyRequest::default_instance_ = NULL; + +emptyRequest* emptyRequest::New() const { + return new emptyRequest; +} + +void emptyRequest::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool emptyRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + } + return true; +#undef DO_ +} + +void emptyRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* emptyRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int emptyRequest::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void emptyRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const emptyRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void emptyRequest::MergeFrom(const emptyRequest& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void emptyRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void emptyRequest::CopyFrom(const emptyRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool emptyRequest::IsInitialized() const { + + return true; +} + +void emptyRequest::Swap(emptyRequest* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata emptyRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = emptyRequest_descriptor_; + metadata.reflection = emptyRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +emptyResponse::emptyResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void emptyResponse::InitAsDefaultInstance() { +} + +emptyResponse::emptyResponse(const emptyResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void emptyResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +emptyResponse::~emptyResponse() { + SharedDtor(); +} + +void emptyResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void emptyResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* emptyResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return emptyResponse_descriptor_; +} + +const emptyResponse& emptyResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_include_2fCommon_2eproto(); + return *default_instance_; +} + +emptyResponse* emptyResponse::default_instance_ = NULL; + +emptyResponse* emptyResponse::New() const { + return new emptyResponse; +} + +void emptyResponse::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool emptyResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + } + return true; +#undef DO_ +} + +void emptyResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* emptyResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int emptyResponse::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void emptyResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const emptyResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void emptyResponse::MergeFrom(const emptyResponse& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void emptyResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void emptyResponse::CopyFrom(const emptyResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool emptyResponse::IsInitialized() const { + + return true; +} + +void emptyResponse::Swap(emptyResponse* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata emptyResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = emptyResponse_descriptor_; + metadata.reflection = emptyResponse_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +// @@protoc_insertion_point(global_scope) diff --git a/cpp/generated/include/Common.pb.h b/cpp/generated/include/Common.pb.h new file mode 100644 index 0000000..f7e9eb2 --- /dev/null +++ b/cpp/generated/include/Common.pb.h @@ -0,0 +1,212 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: include/Common.proto + +#ifndef PROTOBUF_include_2fCommon_2eproto__INCLUDED +#define PROTOBUF_include_2fCommon_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2005000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_include_2fCommon_2eproto(); +void protobuf_AssignDesc_include_2fCommon_2eproto(); +void protobuf_ShutdownFile_include_2fCommon_2eproto(); + +class emptyRequest; +class emptyResponse; + +// =================================================================== + +class emptyRequest : public ::google::protobuf::Message { + public: + emptyRequest(); + virtual ~emptyRequest(); + + emptyRequest(const emptyRequest& from); + + inline emptyRequest& operator=(const emptyRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const emptyRequest& default_instance(); + + void Swap(emptyRequest* other); + + // implements Message ---------------------------------------------- + + emptyRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const emptyRequest& from); + void MergeFrom(const emptyRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.emptyRequest) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[1]; + + friend void protobuf_AddDesc_include_2fCommon_2eproto(); + friend void protobuf_AssignDesc_include_2fCommon_2eproto(); + friend void protobuf_ShutdownFile_include_2fCommon_2eproto(); + + void InitAsDefaultInstance(); + static emptyRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class emptyResponse : public ::google::protobuf::Message { + public: + emptyResponse(); + virtual ~emptyResponse(); + + emptyResponse(const emptyResponse& from); + + inline emptyResponse& operator=(const emptyResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const emptyResponse& default_instance(); + + void Swap(emptyResponse* other); + + // implements Message ---------------------------------------------- + + emptyResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const emptyResponse& from); + void MergeFrom(const emptyResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.emptyResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[1]; + + friend void protobuf_AddDesc_include_2fCommon_2eproto(); + friend void protobuf_AssignDesc_include_2fCommon_2eproto(); + friend void protobuf_ShutdownFile_include_2fCommon_2eproto(); + + void InitAsDefaultInstance(); + static emptyResponse* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// emptyRequest + +// ------------------------------------------------------------------- + +// emptyResponse + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_include_2fCommon_2eproto__INCLUDED diff --git a/cpp/generated/include/PBRPC.pb.cc b/cpp/generated/include/PBRPC.pb.cc new file mode 100644 index 0000000..c6f0748 --- /dev/null +++ b/cpp/generated/include/PBRPC.pb.cc @@ -0,0 +1,111 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: include/PBRPC.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "include/PBRPC.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +namespace { + + +} // namespace + + +void protobuf_AssignDesc_include_2fPBRPC_2eproto() { + protobuf_AddDesc_include_2fPBRPC_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "include/PBRPC.proto"); + GOOGLE_CHECK(file != NULL); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_include_2fPBRPC_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); +} + +} // namespace + +void protobuf_ShutdownFile_include_2fPBRPC_2eproto() { +} + +void protobuf_AddDesc_include_2fPBRPC_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\023include/PBRPC.proto\022\016xtreemfs.pbrpc\032 g" + "oogle/protobuf/descriptor.proto:1\n\007proc_" + "id\022\036.google.protobuf.MethodOptions\030\321\206\003 \001" + "(\007:1\n\007data_in\022\036.google.protobuf.MethodOp" + "tions\030\324\206\003 \001(\010:2\n\010data_out\022\036.google.proto" + "buf.MethodOptions\030\323\206\003 \001(\010:7\n\014interface_i" + "d\022\037.google.protobuf.ServiceOptions\030\322\206\003 \001" + "(\007B3\n1org.xtreemfs.foundation.pbrpc.gene" + "ratedinterfaces", 335); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "include/PBRPC.proto", &protobuf_RegisterTypes); + ::google::protobuf::internal::ExtensionSet::RegisterExtension( + &::google::protobuf::MethodOptions::default_instance(), + 50001, 7, false, false); + ::google::protobuf::internal::ExtensionSet::RegisterExtension( + &::google::protobuf::MethodOptions::default_instance(), + 50004, 8, false, false); + ::google::protobuf::internal::ExtensionSet::RegisterExtension( + &::google::protobuf::MethodOptions::default_instance(), + 50003, 8, false, false); + ::google::protobuf::internal::ExtensionSet::RegisterExtension( + &::google::protobuf::ServiceOptions::default_instance(), + 50002, 7, false, false); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_include_2fPBRPC_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_include_2fPBRPC_2eproto { + StaticDescriptorInitializer_include_2fPBRPC_2eproto() { + protobuf_AddDesc_include_2fPBRPC_2eproto(); + } +} static_descriptor_initializer_include_2fPBRPC_2eproto_; +::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false > + proc_id(kProcIdFieldNumber, 0u); +::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false > + data_in(kDataInFieldNumber, false); +::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false > + data_out(kDataOutFieldNumber, false); +::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false > + interface_id(kInterfaceIdFieldNumber, 0u); + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +// @@protoc_insertion_point(global_scope) diff --git a/cpp/generated/include/PBRPC.pb.h b/cpp/generated/include/PBRPC.pb.h new file mode 100644 index 0000000..1151f71 --- /dev/null +++ b/cpp/generated/include/PBRPC.pb.h @@ -0,0 +1,78 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: include/PBRPC.proto + +#ifndef PROTOBUF_include_2fPBRPC_2eproto__INCLUDED +#define PROTOBUF_include_2fPBRPC_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2005000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include "google/protobuf/descriptor.pb.h" +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_include_2fPBRPC_2eproto(); +void protobuf_AssignDesc_include_2fPBRPC_2eproto(); +void protobuf_ShutdownFile_include_2fPBRPC_2eproto(); + + +// =================================================================== + + +// =================================================================== + +static const int kProcIdFieldNumber = 50001; +extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false > + proc_id; +static const int kDataInFieldNumber = 50004; +extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false > + data_in; +static const int kDataOutFieldNumber = 50003; +extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false > + data_out; +static const int kInterfaceIdFieldNumber = 50002; +extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions, + ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false > + interface_id; + +// =================================================================== + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_include_2fPBRPC_2eproto__INCLUDED diff --git a/cpp/generated/pbrpc/Ping.pb.cc b/cpp/generated/pbrpc/Ping.pb.cc new file mode 100644 index 0000000..e90bd96 --- /dev/null +++ b/cpp/generated/pbrpc/Ping.pb.cc @@ -0,0 +1,1529 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: pbrpc/Ping.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "pbrpc/Ping.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +namespace { + +const ::google::protobuf::Descriptor* PingRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PingRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* PingResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PingResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* PingResponse_PingResult_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PingResponse_PingResult_reflection_ = NULL; +const ::google::protobuf::Descriptor* PingResponse_PingError_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PingResponse_PingError_reflection_ = NULL; +const ::google::protobuf::Descriptor* Ping_emptyRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Ping_emptyRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* Ping_emptyResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Ping_emptyResponse_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_pbrpc_2fPing_2eproto() { + protobuf_AddDesc_pbrpc_2fPing_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "pbrpc/Ping.proto"); + GOOGLE_CHECK(file != NULL); + PingRequest_descriptor_ = file->message_type(0); + static const int PingRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingRequest, text_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingRequest, senderror_), + }; + PingRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + PingRequest_descriptor_, + PingRequest::default_instance_, + PingRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(PingRequest)); + PingResponse_descriptor_ = file->message_type(1); + static const int PingResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse, result_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse, error_), + }; + PingResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + PingResponse_descriptor_, + PingResponse::default_instance_, + PingResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(PingResponse)); + PingResponse_PingResult_descriptor_ = PingResponse_descriptor_->nested_type(0); + static const int PingResponse_PingResult_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingResult, text_), + }; + PingResponse_PingResult_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + PingResponse_PingResult_descriptor_, + PingResponse_PingResult::default_instance_, + PingResponse_PingResult_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingResult, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingResult, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(PingResponse_PingResult)); + PingResponse_PingError_descriptor_ = PingResponse_descriptor_->nested_type(1); + static const int PingResponse_PingError_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingError, errormessage_), + }; + PingResponse_PingError_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + PingResponse_PingError_descriptor_, + PingResponse_PingError::default_instance_, + PingResponse_PingError_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingError, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingError, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(PingResponse_PingError)); + Ping_emptyRequest_descriptor_ = file->message_type(2); + static const int Ping_emptyRequest_offsets_[1] = { + }; + Ping_emptyRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Ping_emptyRequest_descriptor_, + Ping_emptyRequest::default_instance_, + Ping_emptyRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ping_emptyRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ping_emptyRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Ping_emptyRequest)); + Ping_emptyResponse_descriptor_ = file->message_type(3); + static const int Ping_emptyResponse_offsets_[1] = { + }; + Ping_emptyResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Ping_emptyResponse_descriptor_, + Ping_emptyResponse::default_instance_, + Ping_emptyResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ping_emptyResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ping_emptyResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Ping_emptyResponse)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_pbrpc_2fPing_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PingRequest_descriptor_, &PingRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PingResponse_descriptor_, &PingResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PingResponse_PingResult_descriptor_, &PingResponse_PingResult::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PingResponse_PingError_descriptor_, &PingResponse_PingError::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Ping_emptyRequest_descriptor_, &Ping_emptyRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Ping_emptyResponse_descriptor_, &Ping_emptyResponse::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_pbrpc_2fPing_2eproto() { + delete PingRequest::default_instance_; + delete PingRequest_reflection_; + delete PingResponse::default_instance_; + delete PingResponse_reflection_; + delete PingResponse_PingResult::default_instance_; + delete PingResponse_PingResult_reflection_; + delete PingResponse_PingError::default_instance_; + delete PingResponse_PingError_reflection_; + delete Ping_emptyRequest::default_instance_; + delete Ping_emptyRequest_reflection_; + delete Ping_emptyResponse::default_instance_; + delete Ping_emptyResponse_reflection_; +} + +void protobuf_AddDesc_pbrpc_2fPing_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fPBRPC_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\020pbrpc/Ping.proto\022\016xtreemfs.pbrpc\032\023incl" + "ude/PBRPC.proto\".\n\013PingRequest\022\014\n\004text\030\001" + " \002(\t\022\021\n\tsendError\030\002 \002(\010\"\275\001\n\014PingResponse" + "\0227\n\006result\030\001 \001(\0132\'.xtreemfs.pbrpc.PingRe" + "sponse.PingResult\0225\n\005error\030\002 \001(\0132&.xtree" + "mfs.pbrpc.PingResponse.PingError\032\032\n\nPing" + "Result\022\014\n\004text\030\001 \002(\t\032!\n\tPingError\022\024\n\014err" + "orMessage\030\001 \002(\t\"\023\n\021Ping_emptyRequest\"\024\n\022" + "Ping_emptyResponse2\305\001\n\013PingService\022P\n\006do" + "Ping\022\033.xtreemfs.pbrpc.PingRequest\032\034.xtre" + "emfs.pbrpc.PingResponse\"\013\215\265\030\001\000\000\000\240\265\030\001\022[\n\t" + "emptyPing\022!.xtreemfs.pbrpc.Ping_emptyReq" + "uest\032\".xtreemfs.pbrpc.Ping_emptyResponse" + "\"\007\215\265\030\002\000\000\000\032\007\225\265\030\001\000\000\000B3\n1org.xtreemfs.found" + "ation.pbrpc.generatedinterfaces", 591); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "pbrpc/Ping.proto", &protobuf_RegisterTypes); + PingRequest::default_instance_ = new PingRequest(); + PingResponse::default_instance_ = new PingResponse(); + PingResponse_PingResult::default_instance_ = new PingResponse_PingResult(); + PingResponse_PingError::default_instance_ = new PingResponse_PingError(); + Ping_emptyRequest::default_instance_ = new Ping_emptyRequest(); + Ping_emptyResponse::default_instance_ = new Ping_emptyResponse(); + PingRequest::default_instance_->InitAsDefaultInstance(); + PingResponse::default_instance_->InitAsDefaultInstance(); + PingResponse_PingResult::default_instance_->InitAsDefaultInstance(); + PingResponse_PingError::default_instance_->InitAsDefaultInstance(); + Ping_emptyRequest::default_instance_->InitAsDefaultInstance(); + Ping_emptyResponse::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pbrpc_2fPing_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_pbrpc_2fPing_2eproto { + StaticDescriptorInitializer_pbrpc_2fPing_2eproto() { + protobuf_AddDesc_pbrpc_2fPing_2eproto(); + } +} static_descriptor_initializer_pbrpc_2fPing_2eproto_; + +// =================================================================== + +#ifndef _MSC_VER +const int PingRequest::kTextFieldNumber; +const int PingRequest::kSendErrorFieldNumber; +#endif // !_MSC_VER + +PingRequest::PingRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void PingRequest::InitAsDefaultInstance() { +} + +PingRequest::PingRequest(const PingRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void PingRequest::SharedCtor() { + _cached_size_ = 0; + text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + senderror_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PingRequest::~PingRequest() { + SharedDtor(); +} + +void PingRequest::SharedDtor() { + if (text_ != &::google::protobuf::internal::kEmptyString) { + delete text_; + } + if (this != default_instance_) { + } +} + +void PingRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PingRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PingRequest_descriptor_; +} + +const PingRequest& PingRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); + return *default_instance_; +} + +PingRequest* PingRequest::default_instance_ = NULL; + +PingRequest* PingRequest::New() const { + return new PingRequest; +} + +void PingRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_text()) { + if (text_ != &::google::protobuf::internal::kEmptyString) { + text_->clear(); + } + } + senderror_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool PingRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string text = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_text())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->text().data(), this->text().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_sendError; + break; + } + + // required bool sendError = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_sendError: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &senderror_))); + set_has_senderror(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void PingRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string text = 1; + if (has_text()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->text().data(), this->text().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->text(), output); + } + + // required bool sendError = 2; + if (has_senderror()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->senderror(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* PingRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string text = 1; + if (has_text()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->text().data(), this->text().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->text(), target); + } + + // required bool sendError = 2; + if (has_senderror()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->senderror(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int PingRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string text = 1; + if (has_text()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->text()); + } + + // required bool sendError = 2; + if (has_senderror()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PingRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const PingRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void PingRequest::MergeFrom(const PingRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_text()) { + set_text(from.text()); + } + if (from.has_senderror()) { + set_senderror(from.senderror()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void PingRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PingRequest::CopyFrom(const PingRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PingRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void PingRequest::Swap(PingRequest* other) { + if (other != this) { + std::swap(text_, other->text_); + std::swap(senderror_, other->senderror_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata PingRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PingRequest_descriptor_; + metadata.reflection = PingRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int PingResponse_PingResult::kTextFieldNumber; +#endif // !_MSC_VER + +PingResponse_PingResult::PingResponse_PingResult() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void PingResponse_PingResult::InitAsDefaultInstance() { +} + +PingResponse_PingResult::PingResponse_PingResult(const PingResponse_PingResult& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void PingResponse_PingResult::SharedCtor() { + _cached_size_ = 0; + text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PingResponse_PingResult::~PingResponse_PingResult() { + SharedDtor(); +} + +void PingResponse_PingResult::SharedDtor() { + if (text_ != &::google::protobuf::internal::kEmptyString) { + delete text_; + } + if (this != default_instance_) { + } +} + +void PingResponse_PingResult::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PingResponse_PingResult::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PingResponse_PingResult_descriptor_; +} + +const PingResponse_PingResult& PingResponse_PingResult::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); + return *default_instance_; +} + +PingResponse_PingResult* PingResponse_PingResult::default_instance_ = NULL; + +PingResponse_PingResult* PingResponse_PingResult::New() const { + return new PingResponse_PingResult; +} + +void PingResponse_PingResult::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_text()) { + if (text_ != &::google::protobuf::internal::kEmptyString) { + text_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool PingResponse_PingResult::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string text = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_text())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->text().data(), this->text().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void PingResponse_PingResult::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string text = 1; + if (has_text()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->text().data(), this->text().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->text(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* PingResponse_PingResult::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string text = 1; + if (has_text()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->text().data(), this->text().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->text(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int PingResponse_PingResult::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string text = 1; + if (has_text()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->text()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PingResponse_PingResult::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const PingResponse_PingResult* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void PingResponse_PingResult::MergeFrom(const PingResponse_PingResult& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_text()) { + set_text(from.text()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void PingResponse_PingResult::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PingResponse_PingResult::CopyFrom(const PingResponse_PingResult& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PingResponse_PingResult::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void PingResponse_PingResult::Swap(PingResponse_PingResult* other) { + if (other != this) { + std::swap(text_, other->text_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata PingResponse_PingResult::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PingResponse_PingResult_descriptor_; + metadata.reflection = PingResponse_PingResult_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int PingResponse_PingError::kErrorMessageFieldNumber; +#endif // !_MSC_VER + +PingResponse_PingError::PingResponse_PingError() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void PingResponse_PingError::InitAsDefaultInstance() { +} + +PingResponse_PingError::PingResponse_PingError(const PingResponse_PingError& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void PingResponse_PingError::SharedCtor() { + _cached_size_ = 0; + errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PingResponse_PingError::~PingResponse_PingError() { + SharedDtor(); +} + +void PingResponse_PingError::SharedDtor() { + if (errormessage_ != &::google::protobuf::internal::kEmptyString) { + delete errormessage_; + } + if (this != default_instance_) { + } +} + +void PingResponse_PingError::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PingResponse_PingError::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PingResponse_PingError_descriptor_; +} + +const PingResponse_PingError& PingResponse_PingError::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); + return *default_instance_; +} + +PingResponse_PingError* PingResponse_PingError::default_instance_ = NULL; + +PingResponse_PingError* PingResponse_PingError::New() const { + return new PingResponse_PingError; +} + +void PingResponse_PingError::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_errormessage()) { + if (errormessage_ != &::google::protobuf::internal::kEmptyString) { + errormessage_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool PingResponse_PingError::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string errorMessage = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_errormessage())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->errormessage().data(), this->errormessage().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void PingResponse_PingError::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string errorMessage = 1; + if (has_errormessage()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->errormessage().data(), this->errormessage().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->errormessage(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* PingResponse_PingError::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string errorMessage = 1; + if (has_errormessage()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->errormessage().data(), this->errormessage().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->errormessage(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int PingResponse_PingError::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string errorMessage = 1; + if (has_errormessage()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->errormessage()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PingResponse_PingError::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const PingResponse_PingError* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void PingResponse_PingError::MergeFrom(const PingResponse_PingError& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_errormessage()) { + set_errormessage(from.errormessage()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void PingResponse_PingError::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PingResponse_PingError::CopyFrom(const PingResponse_PingError& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PingResponse_PingError::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void PingResponse_PingError::Swap(PingResponse_PingError* other) { + if (other != this) { + std::swap(errormessage_, other->errormessage_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata PingResponse_PingError::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PingResponse_PingError_descriptor_; + metadata.reflection = PingResponse_PingError_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int PingResponse::kResultFieldNumber; +const int PingResponse::kErrorFieldNumber; +#endif // !_MSC_VER + +PingResponse::PingResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void PingResponse::InitAsDefaultInstance() { + result_ = const_cast< ::xtreemfs::pbrpc::PingResponse_PingResult*>(&::xtreemfs::pbrpc::PingResponse_PingResult::default_instance()); + error_ = const_cast< ::xtreemfs::pbrpc::PingResponse_PingError*>(&::xtreemfs::pbrpc::PingResponse_PingError::default_instance()); +} + +PingResponse::PingResponse(const PingResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void PingResponse::SharedCtor() { + _cached_size_ = 0; + result_ = NULL; + error_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PingResponse::~PingResponse() { + SharedDtor(); +} + +void PingResponse::SharedDtor() { + if (this != default_instance_) { + delete result_; + delete error_; + } +} + +void PingResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PingResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PingResponse_descriptor_; +} + +const PingResponse& PingResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); + return *default_instance_; +} + +PingResponse* PingResponse::default_instance_ = NULL; + +PingResponse* PingResponse::New() const { + return new PingResponse; +} + +void PingResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_result()) { + if (result_ != NULL) result_->::xtreemfs::pbrpc::PingResponse_PingResult::Clear(); + } + if (has_error()) { + if (error_ != NULL) error_->::xtreemfs::pbrpc::PingResponse_PingError::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool PingResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_result())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_error; + break; + } + + // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_error: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_error())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void PingResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1; + if (has_result()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->result(), output); + } + + // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2; + if (has_error()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->error(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* PingResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1; + if (has_result()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->result(), target); + } + + // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2; + if (has_error()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->error(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int PingResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1; + if (has_result()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->result()); + } + + // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2; + if (has_error()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->error()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PingResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const PingResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void PingResponse::MergeFrom(const PingResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_result()) { + mutable_result()->::xtreemfs::pbrpc::PingResponse_PingResult::MergeFrom(from.result()); + } + if (from.has_error()) { + mutable_error()->::xtreemfs::pbrpc::PingResponse_PingError::MergeFrom(from.error()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void PingResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PingResponse::CopyFrom(const PingResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PingResponse::IsInitialized() const { + + if (has_result()) { + if (!this->result().IsInitialized()) return false; + } + if (has_error()) { + if (!this->error().IsInitialized()) return false; + } + return true; +} + +void PingResponse::Swap(PingResponse* other) { + if (other != this) { + std::swap(result_, other->result_); + std::swap(error_, other->error_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata PingResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PingResponse_descriptor_; + metadata.reflection = PingResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +Ping_emptyRequest::Ping_emptyRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Ping_emptyRequest::InitAsDefaultInstance() { +} + +Ping_emptyRequest::Ping_emptyRequest(const Ping_emptyRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Ping_emptyRequest::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Ping_emptyRequest::~Ping_emptyRequest() { + SharedDtor(); +} + +void Ping_emptyRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void Ping_emptyRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Ping_emptyRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Ping_emptyRequest_descriptor_; +} + +const Ping_emptyRequest& Ping_emptyRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); + return *default_instance_; +} + +Ping_emptyRequest* Ping_emptyRequest::default_instance_ = NULL; + +Ping_emptyRequest* Ping_emptyRequest::New() const { + return new Ping_emptyRequest; +} + +void Ping_emptyRequest::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Ping_emptyRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + } + return true; +#undef DO_ +} + +void Ping_emptyRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Ping_emptyRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Ping_emptyRequest::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Ping_emptyRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Ping_emptyRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Ping_emptyRequest::MergeFrom(const Ping_emptyRequest& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Ping_emptyRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Ping_emptyRequest::CopyFrom(const Ping_emptyRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Ping_emptyRequest::IsInitialized() const { + + return true; +} + +void Ping_emptyRequest::Swap(Ping_emptyRequest* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Ping_emptyRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Ping_emptyRequest_descriptor_; + metadata.reflection = Ping_emptyRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +Ping_emptyResponse::Ping_emptyResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Ping_emptyResponse::InitAsDefaultInstance() { +} + +Ping_emptyResponse::Ping_emptyResponse(const Ping_emptyResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Ping_emptyResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Ping_emptyResponse::~Ping_emptyResponse() { + SharedDtor(); +} + +void Ping_emptyResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void Ping_emptyResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Ping_emptyResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Ping_emptyResponse_descriptor_; +} + +const Ping_emptyResponse& Ping_emptyResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); + return *default_instance_; +} + +Ping_emptyResponse* Ping_emptyResponse::default_instance_ = NULL; + +Ping_emptyResponse* Ping_emptyResponse::New() const { + return new Ping_emptyResponse; +} + +void Ping_emptyResponse::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Ping_emptyResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + } + return true; +#undef DO_ +} + +void Ping_emptyResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Ping_emptyResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Ping_emptyResponse::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Ping_emptyResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Ping_emptyResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Ping_emptyResponse::MergeFrom(const Ping_emptyResponse& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Ping_emptyResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Ping_emptyResponse::CopyFrom(const Ping_emptyResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Ping_emptyResponse::IsInitialized() const { + + return true; +} + +void Ping_emptyResponse::Swap(Ping_emptyResponse* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Ping_emptyResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Ping_emptyResponse_descriptor_; + metadata.reflection = Ping_emptyResponse_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +// @@protoc_insertion_point(global_scope) diff --git a/cpp/generated/pbrpc/Ping.pb.h b/cpp/generated/pbrpc/Ping.pb.h new file mode 100644 index 0000000..5e9c266 --- /dev/null +++ b/cpp/generated/pbrpc/Ping.pb.h @@ -0,0 +1,911 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: pbrpc/Ping.proto + +#ifndef PROTOBUF_pbrpc_2fPing_2eproto__INCLUDED +#define PROTOBUF_pbrpc_2fPing_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2005000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include "include/PBRPC.pb.h" +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_pbrpc_2fPing_2eproto(); +void protobuf_AssignDesc_pbrpc_2fPing_2eproto(); +void protobuf_ShutdownFile_pbrpc_2fPing_2eproto(); + +class PingRequest; +class PingResponse; +class PingResponse_PingResult; +class PingResponse_PingError; +class Ping_emptyRequest; +class Ping_emptyResponse; + +// =================================================================== + +class PingRequest : public ::google::protobuf::Message { + public: + PingRequest(); + virtual ~PingRequest(); + + PingRequest(const PingRequest& from); + + inline PingRequest& operator=(const PingRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PingRequest& default_instance(); + + void Swap(PingRequest* other); + + // implements Message ---------------------------------------------- + + PingRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PingRequest& from); + void MergeFrom(const PingRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string text = 1; + inline bool has_text() const; + inline void clear_text(); + static const int kTextFieldNumber = 1; + inline const ::std::string& text() const; + inline void set_text(const ::std::string& value); + inline void set_text(const char* value); + inline void set_text(const char* value, size_t size); + inline ::std::string* mutable_text(); + inline ::std::string* release_text(); + inline void set_allocated_text(::std::string* text); + + // required bool sendError = 2; + inline bool has_senderror() const; + inline void clear_senderror(); + static const int kSendErrorFieldNumber = 2; + inline bool senderror() const; + inline void set_senderror(bool value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.PingRequest) + private: + inline void set_has_text(); + inline void clear_has_text(); + inline void set_has_senderror(); + inline void clear_has_senderror(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* text_; + bool senderror_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fPing_2eproto(); + + void InitAsDefaultInstance(); + static PingRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class PingResponse_PingResult : public ::google::protobuf::Message { + public: + PingResponse_PingResult(); + virtual ~PingResponse_PingResult(); + + PingResponse_PingResult(const PingResponse_PingResult& from); + + inline PingResponse_PingResult& operator=(const PingResponse_PingResult& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PingResponse_PingResult& default_instance(); + + void Swap(PingResponse_PingResult* other); + + // implements Message ---------------------------------------------- + + PingResponse_PingResult* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PingResponse_PingResult& from); + void MergeFrom(const PingResponse_PingResult& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string text = 1; + inline bool has_text() const; + inline void clear_text(); + static const int kTextFieldNumber = 1; + inline const ::std::string& text() const; + inline void set_text(const ::std::string& value); + inline void set_text(const char* value); + inline void set_text(const char* value, size_t size); + inline ::std::string* mutable_text(); + inline ::std::string* release_text(); + inline void set_allocated_text(::std::string* text); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.PingResponse.PingResult) + private: + inline void set_has_text(); + inline void clear_has_text(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* text_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fPing_2eproto(); + + void InitAsDefaultInstance(); + static PingResponse_PingResult* default_instance_; +}; +// ------------------------------------------------------------------- + +class PingResponse_PingError : public ::google::protobuf::Message { + public: + PingResponse_PingError(); + virtual ~PingResponse_PingError(); + + PingResponse_PingError(const PingResponse_PingError& from); + + inline PingResponse_PingError& operator=(const PingResponse_PingError& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PingResponse_PingError& default_instance(); + + void Swap(PingResponse_PingError* other); + + // implements Message ---------------------------------------------- + + PingResponse_PingError* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PingResponse_PingError& from); + void MergeFrom(const PingResponse_PingError& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string errorMessage = 1; + inline bool has_errormessage() const; + inline void clear_errormessage(); + static const int kErrorMessageFieldNumber = 1; + inline const ::std::string& errormessage() const; + inline void set_errormessage(const ::std::string& value); + inline void set_errormessage(const char* value); + inline void set_errormessage(const char* value, size_t size); + inline ::std::string* mutable_errormessage(); + inline ::std::string* release_errormessage(); + inline void set_allocated_errormessage(::std::string* errormessage); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.PingResponse.PingError) + private: + inline void set_has_errormessage(); + inline void clear_has_errormessage(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* errormessage_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fPing_2eproto(); + + void InitAsDefaultInstance(); + static PingResponse_PingError* default_instance_; +}; +// ------------------------------------------------------------------- + +class PingResponse : public ::google::protobuf::Message { + public: + PingResponse(); + virtual ~PingResponse(); + + PingResponse(const PingResponse& from); + + inline PingResponse& operator=(const PingResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PingResponse& default_instance(); + + void Swap(PingResponse* other); + + // implements Message ---------------------------------------------- + + PingResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PingResponse& from); + void MergeFrom(const PingResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef PingResponse_PingResult PingResult; + typedef PingResponse_PingError PingError; + + // accessors ------------------------------------------------------- + + // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1; + inline bool has_result() const; + inline void clear_result(); + static const int kResultFieldNumber = 1; + inline const ::xtreemfs::pbrpc::PingResponse_PingResult& result() const; + inline ::xtreemfs::pbrpc::PingResponse_PingResult* mutable_result(); + inline ::xtreemfs::pbrpc::PingResponse_PingResult* release_result(); + inline void set_allocated_result(::xtreemfs::pbrpc::PingResponse_PingResult* result); + + // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2; + inline bool has_error() const; + inline void clear_error(); + static const int kErrorFieldNumber = 2; + inline const ::xtreemfs::pbrpc::PingResponse_PingError& error() const; + inline ::xtreemfs::pbrpc::PingResponse_PingError* mutable_error(); + inline ::xtreemfs::pbrpc::PingResponse_PingError* release_error(); + inline void set_allocated_error(::xtreemfs::pbrpc::PingResponse_PingError* error); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.PingResponse) + private: + inline void set_has_result(); + inline void clear_has_result(); + inline void set_has_error(); + inline void clear_has_error(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::PingResponse_PingResult* result_; + ::xtreemfs::pbrpc::PingResponse_PingError* error_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fPing_2eproto(); + + void InitAsDefaultInstance(); + static PingResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class Ping_emptyRequest : public ::google::protobuf::Message { + public: + Ping_emptyRequest(); + virtual ~Ping_emptyRequest(); + + Ping_emptyRequest(const Ping_emptyRequest& from); + + inline Ping_emptyRequest& operator=(const Ping_emptyRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Ping_emptyRequest& default_instance(); + + void Swap(Ping_emptyRequest* other); + + // implements Message ---------------------------------------------- + + Ping_emptyRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Ping_emptyRequest& from); + void MergeFrom(const Ping_emptyRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Ping_emptyRequest) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[1]; + + friend void protobuf_AddDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fPing_2eproto(); + + void InitAsDefaultInstance(); + static Ping_emptyRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class Ping_emptyResponse : public ::google::protobuf::Message { + public: + Ping_emptyResponse(); + virtual ~Ping_emptyResponse(); + + Ping_emptyResponse(const Ping_emptyResponse& from); + + inline Ping_emptyResponse& operator=(const Ping_emptyResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Ping_emptyResponse& default_instance(); + + void Swap(Ping_emptyResponse* other); + + // implements Message ---------------------------------------------- + + Ping_emptyResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Ping_emptyResponse& from); + void MergeFrom(const Ping_emptyResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Ping_emptyResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[1]; + + friend void protobuf_AddDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fPing_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fPing_2eproto(); + + void InitAsDefaultInstance(); + static Ping_emptyResponse* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// PingRequest + +// required string text = 1; +inline bool PingRequest::has_text() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PingRequest::set_has_text() { + _has_bits_[0] |= 0x00000001u; +} +inline void PingRequest::clear_has_text() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PingRequest::clear_text() { + if (text_ != &::google::protobuf::internal::kEmptyString) { + text_->clear(); + } + clear_has_text(); +} +inline const ::std::string& PingRequest::text() const { + return *text_; +} +inline void PingRequest::set_text(const ::std::string& value) { + set_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + text_ = new ::std::string; + } + text_->assign(value); +} +inline void PingRequest::set_text(const char* value) { + set_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + text_ = new ::std::string; + } + text_->assign(value); +} +inline void PingRequest::set_text(const char* value, size_t size) { + set_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + text_ = new ::std::string; + } + text_->assign(reinterpret_cast(value), size); +} +inline ::std::string* PingRequest::mutable_text() { + set_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + text_ = new ::std::string; + } + return text_; +} +inline ::std::string* PingRequest::release_text() { + clear_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = text_; + text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void PingRequest::set_allocated_text(::std::string* text) { + if (text_ != &::google::protobuf::internal::kEmptyString) { + delete text_; + } + if (text) { + set_has_text(); + text_ = text; + } else { + clear_has_text(); + text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required bool sendError = 2; +inline bool PingRequest::has_senderror() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PingRequest::set_has_senderror() { + _has_bits_[0] |= 0x00000002u; +} +inline void PingRequest::clear_has_senderror() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PingRequest::clear_senderror() { + senderror_ = false; + clear_has_senderror(); +} +inline bool PingRequest::senderror() const { + return senderror_; +} +inline void PingRequest::set_senderror(bool value) { + set_has_senderror(); + senderror_ = value; +} + +// ------------------------------------------------------------------- + +// PingResponse_PingResult + +// required string text = 1; +inline bool PingResponse_PingResult::has_text() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PingResponse_PingResult::set_has_text() { + _has_bits_[0] |= 0x00000001u; +} +inline void PingResponse_PingResult::clear_has_text() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PingResponse_PingResult::clear_text() { + if (text_ != &::google::protobuf::internal::kEmptyString) { + text_->clear(); + } + clear_has_text(); +} +inline const ::std::string& PingResponse_PingResult::text() const { + return *text_; +} +inline void PingResponse_PingResult::set_text(const ::std::string& value) { + set_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + text_ = new ::std::string; + } + text_->assign(value); +} +inline void PingResponse_PingResult::set_text(const char* value) { + set_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + text_ = new ::std::string; + } + text_->assign(value); +} +inline void PingResponse_PingResult::set_text(const char* value, size_t size) { + set_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + text_ = new ::std::string; + } + text_->assign(reinterpret_cast(value), size); +} +inline ::std::string* PingResponse_PingResult::mutable_text() { + set_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + text_ = new ::std::string; + } + return text_; +} +inline ::std::string* PingResponse_PingResult::release_text() { + clear_has_text(); + if (text_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = text_; + text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void PingResponse_PingResult::set_allocated_text(::std::string* text) { + if (text_ != &::google::protobuf::internal::kEmptyString) { + delete text_; + } + if (text) { + set_has_text(); + text_ = text; + } else { + clear_has_text(); + text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// PingResponse_PingError + +// required string errorMessage = 1; +inline bool PingResponse_PingError::has_errormessage() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PingResponse_PingError::set_has_errormessage() { + _has_bits_[0] |= 0x00000001u; +} +inline void PingResponse_PingError::clear_has_errormessage() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PingResponse_PingError::clear_errormessage() { + if (errormessage_ != &::google::protobuf::internal::kEmptyString) { + errormessage_->clear(); + } + clear_has_errormessage(); +} +inline const ::std::string& PingResponse_PingError::errormessage() const { + return *errormessage_; +} +inline void PingResponse_PingError::set_errormessage(const ::std::string& value) { + set_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + errormessage_ = new ::std::string; + } + errormessage_->assign(value); +} +inline void PingResponse_PingError::set_errormessage(const char* value) { + set_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + errormessage_ = new ::std::string; + } + errormessage_->assign(value); +} +inline void PingResponse_PingError::set_errormessage(const char* value, size_t size) { + set_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + errormessage_ = new ::std::string; + } + errormessage_->assign(reinterpret_cast(value), size); +} +inline ::std::string* PingResponse_PingError::mutable_errormessage() { + set_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + errormessage_ = new ::std::string; + } + return errormessage_; +} +inline ::std::string* PingResponse_PingError::release_errormessage() { + clear_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = errormessage_; + errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void PingResponse_PingError::set_allocated_errormessage(::std::string* errormessage) { + if (errormessage_ != &::google::protobuf::internal::kEmptyString) { + delete errormessage_; + } + if (errormessage) { + set_has_errormessage(); + errormessage_ = errormessage; + } else { + clear_has_errormessage(); + errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// PingResponse + +// optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1; +inline bool PingResponse::has_result() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PingResponse::set_has_result() { + _has_bits_[0] |= 0x00000001u; +} +inline void PingResponse::clear_has_result() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PingResponse::clear_result() { + if (result_ != NULL) result_->::xtreemfs::pbrpc::PingResponse_PingResult::Clear(); + clear_has_result(); +} +inline const ::xtreemfs::pbrpc::PingResponse_PingResult& PingResponse::result() const { + return result_ != NULL ? *result_ : *default_instance_->result_; +} +inline ::xtreemfs::pbrpc::PingResponse_PingResult* PingResponse::mutable_result() { + set_has_result(); + if (result_ == NULL) result_ = new ::xtreemfs::pbrpc::PingResponse_PingResult; + return result_; +} +inline ::xtreemfs::pbrpc::PingResponse_PingResult* PingResponse::release_result() { + clear_has_result(); + ::xtreemfs::pbrpc::PingResponse_PingResult* temp = result_; + result_ = NULL; + return temp; +} +inline void PingResponse::set_allocated_result(::xtreemfs::pbrpc::PingResponse_PingResult* result) { + delete result_; + result_ = result; + if (result) { + set_has_result(); + } else { + clear_has_result(); + } +} + +// optional .xtreemfs.pbrpc.PingResponse.PingError error = 2; +inline bool PingResponse::has_error() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PingResponse::set_has_error() { + _has_bits_[0] |= 0x00000002u; +} +inline void PingResponse::clear_has_error() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PingResponse::clear_error() { + if (error_ != NULL) error_->::xtreemfs::pbrpc::PingResponse_PingError::Clear(); + clear_has_error(); +} +inline const ::xtreemfs::pbrpc::PingResponse_PingError& PingResponse::error() const { + return error_ != NULL ? *error_ : *default_instance_->error_; +} +inline ::xtreemfs::pbrpc::PingResponse_PingError* PingResponse::mutable_error() { + set_has_error(); + if (error_ == NULL) error_ = new ::xtreemfs::pbrpc::PingResponse_PingError; + return error_; +} +inline ::xtreemfs::pbrpc::PingResponse_PingError* PingResponse::release_error() { + clear_has_error(); + ::xtreemfs::pbrpc::PingResponse_PingError* temp = error_; + error_ = NULL; + return temp; +} +inline void PingResponse::set_allocated_error(::xtreemfs::pbrpc::PingResponse_PingError* error) { + delete error_; + error_ = error; + if (error) { + set_has_error(); + } else { + clear_has_error(); + } +} + +// ------------------------------------------------------------------- + +// Ping_emptyRequest + +// ------------------------------------------------------------------- + +// Ping_emptyResponse + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_pbrpc_2fPing_2eproto__INCLUDED diff --git a/cpp/generated/pbrpc/PingServiceClient.h b/cpp/generated/pbrpc/PingServiceClient.h new file mode 100644 index 0000000..9c101f0 --- /dev/null +++ b/cpp/generated/pbrpc/PingServiceClient.h @@ -0,0 +1,79 @@ +//automatically generated from Ping.proto at Thu Dec 11 16:09:41 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef PINGSERVICECLIENT_H +#define PINGSERVICECLIENT_H + +#include +#include "pbrpc/RPC.pb.h" +#include "rpc/client.h" +#include "rpc/sync_callback.h" +#include "rpc/callback_interface.h" +#include "pbrpc/Ping.pb.h" + + +namespace xtreemfs { +namespace pbrpc { + using ::xtreemfs::rpc::Client; + using ::xtreemfs::rpc::CallbackInterface; + using ::xtreemfs::rpc::SyncCallback; + + class PingServiceClient { + + public: + PingServiceClient(Client* client) : client_(client) { + } + + virtual ~PingServiceClient() { + } + + void doPing(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::PingRequest* request,const char* data, uint32_t data_length, + CallbackInterface *callback, void *context = NULL) { + client_->sendRequest(address, 1, 1, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::PingResponse(), + context, callback); + } + + SyncCallback* doPing_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::PingRequest* request, const char* data, uint32_t data_length) { + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 1, 1, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::PingResponse(), + NULL, sync_cb); + return sync_cb; + } + + void emptyPing(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::Ping_emptyRequest* request = NULL; + client_->sendRequest(address, 1, 2, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* emptyPing_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::Ping_emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 1, 2, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + private: + Client* client_; + }; + } +} +#endif //PINGSERVICECLIENT_H diff --git a/cpp/generated/pbrpc/PingServiceConstants.h b/cpp/generated/pbrpc/PingServiceConstants.h new file mode 100644 index 0000000..8892de8 --- /dev/null +++ b/cpp/generated/pbrpc/PingServiceConstants.h @@ -0,0 +1,18 @@ +//automatically generated from Ping.proto at Thu Dec 11 16:09:41 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef PINGSERVICECONSTANTS_H_ +#define PINGSERVICECONSTANTS_H_ +#include + +namespace xtreemfs { +namespace pbrpc { + +const uint32_t INTERFACE_ID_PING = 1; +const uint32_t PROC_ID_DOPING = 1; +const uint32_t PROC_ID_EMPTYPING = 2; + +} // namespace pbrpc +} // namespace xtreemfs + +#endif // PINGSERVICECLIENT_H_ diff --git a/cpp/generated/pbrpc/RPC.pb.cc b/cpp/generated/pbrpc/RPC.pb.cc new file mode 100644 index 0000000..5cad7fe --- /dev/null +++ b/cpp/generated/pbrpc/RPC.pb.cc @@ -0,0 +1,2293 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: pbrpc/RPC.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "pbrpc/RPC.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +namespace { + +const ::google::protobuf::Descriptor* UserCredentials_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + UserCredentials_reflection_ = NULL; +const ::google::protobuf::Descriptor* AuthPassword_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AuthPassword_reflection_ = NULL; +const ::google::protobuf::Descriptor* Auth_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Auth_reflection_ = NULL; +const ::google::protobuf::Descriptor* RPCHeader_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RPCHeader_reflection_ = NULL; +const ::google::protobuf::Descriptor* RPCHeader_RequestHeader_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RPCHeader_RequestHeader_reflection_ = NULL; +const ::google::protobuf::Descriptor* RPCHeader_ErrorResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + RPCHeader_ErrorResponse_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* MessageType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* AuthType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* ErrorType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_pbrpc_2fRPC_2eproto() { + protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "pbrpc/RPC.proto"); + GOOGLE_CHECK(file != NULL); + UserCredentials_descriptor_ = file->message_type(0); + static const int UserCredentials_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, username_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, groups_), + }; + UserCredentials_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + UserCredentials_descriptor_, + UserCredentials::default_instance_, + UserCredentials_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(UserCredentials)); + AuthPassword_descriptor_ = file->message_type(1); + static const int AuthPassword_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, password_), + }; + AuthPassword_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AuthPassword_descriptor_, + AuthPassword::default_instance_, + AuthPassword_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AuthPassword)); + Auth_descriptor_ = file->message_type(2); + static const int Auth_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_passwd_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_data_), + }; + Auth_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Auth_descriptor_, + Auth::default_instance_, + Auth_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Auth)); + RPCHeader_descriptor_ = file->message_type(3); + static const int RPCHeader_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, call_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, message_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, request_header_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, error_response_), + }; + RPCHeader_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RPCHeader_descriptor_, + RPCHeader::default_instance_, + RPCHeader_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RPCHeader)); + RPCHeader_RequestHeader_descriptor_ = RPCHeader_descriptor_->nested_type(0); + static const int RPCHeader_RequestHeader_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, interface_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, proc_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, user_creds_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, auth_data_), + }; + RPCHeader_RequestHeader_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RPCHeader_RequestHeader_descriptor_, + RPCHeader_RequestHeader::default_instance_, + RPCHeader_RequestHeader_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RPCHeader_RequestHeader)); + RPCHeader_ErrorResponse_descriptor_ = RPCHeader_descriptor_->nested_type(1); + static const int RPCHeader_ErrorResponse_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, error_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, posix_errno_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, error_message_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, debug_info_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, redirect_to_server_uuid_), + }; + RPCHeader_ErrorResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + RPCHeader_ErrorResponse_descriptor_, + RPCHeader_ErrorResponse::default_instance_, + RPCHeader_ErrorResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(RPCHeader_ErrorResponse)); + MessageType_descriptor_ = file->enum_type(0); + AuthType_descriptor_ = file->enum_type(1); + ErrorType_descriptor_ = file->enum_type(2); + POSIXErrno_descriptor_ = file->enum_type(3); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_pbrpc_2fRPC_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + UserCredentials_descriptor_, &UserCredentials::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AuthPassword_descriptor_, &AuthPassword::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Auth_descriptor_, &Auth::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RPCHeader_descriptor_, &RPCHeader::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RPCHeader_RequestHeader_descriptor_, &RPCHeader_RequestHeader::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + RPCHeader_ErrorResponse_descriptor_, &RPCHeader_ErrorResponse::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto() { + delete UserCredentials::default_instance_; + delete UserCredentials_reflection_; + delete AuthPassword::default_instance_; + delete AuthPassword_reflection_; + delete Auth::default_instance_; + delete Auth_reflection_; + delete RPCHeader::default_instance_; + delete RPCHeader_reflection_; + delete RPCHeader_RequestHeader::default_instance_; + delete RPCHeader_RequestHeader_reflection_; + delete RPCHeader_ErrorResponse::default_instance_; + delete RPCHeader_ErrorResponse_reflection_; +} + +void protobuf_AddDesc_pbrpc_2fRPC_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\017pbrpc/RPC.proto\022\016xtreemfs.pbrpc\"3\n\017Use" + "rCredentials\022\020\n\010username\030\001 \002(\t\022\016\n\006groups" + "\030\002 \003(\t\" \n\014AuthPassword\022\020\n\010password\030\001 \002(\t" + "\"y\n\004Auth\022+\n\tauth_type\030\001 \002(\0162\030.xtreemfs.p" + "brpc.AuthType\0221\n\013auth_passwd\030\003 \001(\0132\034.xtr" + "eemfs.pbrpc.AuthPassword\022\021\n\tauth_data\030\002 " + "\001(\014\"\270\004\n\tRPCHeader\022\017\n\007call_id\030\001 \002(\007\0221\n\014me" + "ssage_type\030\002 \002(\0162\033.xtreemfs.pbrpc.Messag" + "eType\022\?\n\016request_header\030\003 \001(\0132\'.xtreemfs" + ".pbrpc.RPCHeader.RequestHeader\022\?\n\016error_" + "response\030\004 \001(\0132\'.xtreemfs.pbrpc.RPCHeade" + "r.ErrorResponse\032\224\001\n\rRequestHeader\022\024\n\014int" + "erface_id\030\001 \002(\007\022\017\n\007proc_id\030\002 \002(\007\0223\n\nuser" + "_creds\030\003 \002(\0132\037.xtreemfs.pbrpc.UserCreden" + "tials\022\'\n\tauth_data\030\004 \002(\0132\024.xtreemfs.pbrp" + "c.Auth\032\315\001\n\rErrorResponse\022-\n\nerror_type\030\001" + " \002(\0162\031.xtreemfs.pbrpc.ErrorType\022A\n\013posix" + "_errno\030\002 \001(\0162\032.xtreemfs.pbrpc.POSIXErrno" + ":\020POSIX_ERROR_NONE\022\025\n\rerror_message\030\003 \001(" + "\t\022\022\n\ndebug_info\030\004 \001(\t\022\037\n\027redirect_to_ser" + "ver_uuid\030\005 \001(\t*P\n\013MessageType\022\017\n\013RPC_REQ" + "UEST\020\000\022\030\n\024RPC_RESPONSE_SUCCESS\020\001\022\026\n\022RPC_" + "RESPONSE_ERROR\020\002*,\n\010AuthType\022\r\n\tAUTH_NON" + "E\020\000\022\021\n\rAUTH_PASSWORD\020\001*\261\001\n\tErrorType\022\030\n\024" + "INVALID_INTERFACE_ID\020\001\022\023\n\017INVALID_PROC_I" + "D\020\002\022\020\n\014GARBAGE_ARGS\020\003\022\017\n\013AUTH_FAILED\020\004\022\031" + "\n\025INTERNAL_SERVER_ERROR\020\005\022\t\n\005ERRNO\020\006\022\014\n\010" + "REDIRECT\020\007\022\020\n\014INVALID_VIEW\020\010\022\014\n\010IO_ERROR" + "\020d*\212\003\n\nPOSIXErrno\022\025\n\020POSIX_ERROR_NONE\020\217N" + "\022\025\n\021POSIX_ERROR_EPERM\020\001\022\026\n\022POSIX_ERROR_E" + "NOENT\020\002\022\025\n\021POSIX_ERROR_EINTR\020\004\022\023\n\017POSIX_" + "ERROR_EIO\020\005\022\026\n\022POSIX_ERROR_EAGAIN\020\013\022\026\n\022P" + "OSIX_ERROR_EACCES\020\r\022\026\n\022POSIX_ERROR_EEXIS" + "T\020\021\022\025\n\021POSIX_ERROR_EXDEV\020\022\022\026\n\022POSIX_ERRO" + "R_ENODEV\020\023\022\027\n\023POSIX_ERROR_ENOTDIR\020\024\022\026\n\022P" + "OSIX_ERROR_EISDIR\020\025\022\026\n\022POSIX_ERROR_EINVA" + "L\020\026\022\026\n\022POSIX_ERROR_ENOSPC\020\034\022\031\n\025POSIX_ERR" + "OR_ENOTEMPTY\020\'\022\027\n\023POSIX_ERROR_ENODATA\020=B" + "3\n1org.xtreemfs.foundation.pbrpc.generat" + "edinterfaces", 1572); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "pbrpc/RPC.proto", &protobuf_RegisterTypes); + UserCredentials::default_instance_ = new UserCredentials(); + AuthPassword::default_instance_ = new AuthPassword(); + Auth::default_instance_ = new Auth(); + RPCHeader::default_instance_ = new RPCHeader(); + RPCHeader_RequestHeader::default_instance_ = new RPCHeader_RequestHeader(); + RPCHeader_ErrorResponse::default_instance_ = new RPCHeader_ErrorResponse(); + UserCredentials::default_instance_->InitAsDefaultInstance(); + AuthPassword::default_instance_->InitAsDefaultInstance(); + Auth::default_instance_->InitAsDefaultInstance(); + RPCHeader::default_instance_->InitAsDefaultInstance(); + RPCHeader_RequestHeader::default_instance_->InitAsDefaultInstance(); + RPCHeader_ErrorResponse::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pbrpc_2fRPC_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_pbrpc_2fRPC_2eproto { + StaticDescriptorInitializer_pbrpc_2fRPC_2eproto() { + protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + } +} static_descriptor_initializer_pbrpc_2fRPC_2eproto_; +const ::google::protobuf::EnumDescriptor* MessageType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return MessageType_descriptor_; +} +bool MessageType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* AuthType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return AuthType_descriptor_; +} +bool AuthType_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* ErrorType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ErrorType_descriptor_; +} +bool ErrorType_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 100: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor() { + protobuf_AssignDescriptorsOnce(); + return POSIXErrno_descriptor_; +} +bool POSIXErrno_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 4: + case 5: + case 11: + case 13: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 28: + case 39: + case 61: + case 9999: + return true; + default: + return false; + } +} + + +// =================================================================== + +#ifndef _MSC_VER +const int UserCredentials::kUsernameFieldNumber; +const int UserCredentials::kGroupsFieldNumber; +#endif // !_MSC_VER + +UserCredentials::UserCredentials() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void UserCredentials::InitAsDefaultInstance() { +} + +UserCredentials::UserCredentials(const UserCredentials& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void UserCredentials::SharedCtor() { + _cached_size_ = 0; + username_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +UserCredentials::~UserCredentials() { + SharedDtor(); +} + +void UserCredentials::SharedDtor() { + if (username_ != &::google::protobuf::internal::kEmptyString) { + delete username_; + } + if (this != default_instance_) { + } +} + +void UserCredentials::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* UserCredentials::descriptor() { + protobuf_AssignDescriptorsOnce(); + return UserCredentials_descriptor_; +} + +const UserCredentials& UserCredentials::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + return *default_instance_; +} + +UserCredentials* UserCredentials::default_instance_ = NULL; + +UserCredentials* UserCredentials::New() const { + return new UserCredentials; +} + +void UserCredentials::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_username()) { + if (username_ != &::google::protobuf::internal::kEmptyString) { + username_->clear(); + } + } + } + groups_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool UserCredentials::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string username = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_username())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->username().data(), this->username().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_groups; + break; + } + + // repeated string groups = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_groups: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_groups())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->groups(this->groups_size() - 1).data(), + this->groups(this->groups_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_groups; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void UserCredentials::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string username = 1; + if (has_username()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->username().data(), this->username().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->username(), output); + } + + // repeated string groups = 2; + for (int i = 0; i < this->groups_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->groups(i).data(), this->groups(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->groups(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* UserCredentials::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string username = 1; + if (has_username()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->username().data(), this->username().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->username(), target); + } + + // repeated string groups = 2; + for (int i = 0; i < this->groups_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->groups(i).data(), this->groups(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(2, this->groups(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int UserCredentials::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string username = 1; + if (has_username()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->username()); + } + + } + // repeated string groups = 2; + total_size += 1 * this->groups_size(); + for (int i = 0; i < this->groups_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->groups(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void UserCredentials::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const UserCredentials* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void UserCredentials::MergeFrom(const UserCredentials& from) { + GOOGLE_CHECK_NE(&from, this); + groups_.MergeFrom(from.groups_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_username()) { + set_username(from.username()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void UserCredentials::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void UserCredentials::CopyFrom(const UserCredentials& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UserCredentials::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void UserCredentials::Swap(UserCredentials* other) { + if (other != this) { + std::swap(username_, other->username_); + groups_.Swap(&other->groups_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata UserCredentials::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = UserCredentials_descriptor_; + metadata.reflection = UserCredentials_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AuthPassword::kPasswordFieldNumber; +#endif // !_MSC_VER + +AuthPassword::AuthPassword() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void AuthPassword::InitAsDefaultInstance() { +} + +AuthPassword::AuthPassword(const AuthPassword& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void AuthPassword::SharedCtor() { + _cached_size_ = 0; + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AuthPassword::~AuthPassword() { + SharedDtor(); +} + +void AuthPassword::SharedDtor() { + if (password_ != &::google::protobuf::internal::kEmptyString) { + delete password_; + } + if (this != default_instance_) { + } +} + +void AuthPassword::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AuthPassword::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AuthPassword_descriptor_; +} + +const AuthPassword& AuthPassword::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + return *default_instance_; +} + +AuthPassword* AuthPassword::default_instance_ = NULL; + +AuthPassword* AuthPassword::New() const { + return new AuthPassword; +} + +void AuthPassword::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_password()) { + if (password_ != &::google::protobuf::internal::kEmptyString) { + password_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AuthPassword::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string password = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_password())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->password().data(), this->password().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void AuthPassword::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string password = 1; + if (has_password()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->password().data(), this->password().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->password(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* AuthPassword::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string password = 1; + if (has_password()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->password().data(), this->password().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->password(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int AuthPassword::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string password = 1; + if (has_password()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->password()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AuthPassword::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AuthPassword* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AuthPassword::MergeFrom(const AuthPassword& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_password()) { + set_password(from.password()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AuthPassword::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AuthPassword::CopyFrom(const AuthPassword& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AuthPassword::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void AuthPassword::Swap(AuthPassword* other) { + if (other != this) { + std::swap(password_, other->password_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata AuthPassword::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AuthPassword_descriptor_; + metadata.reflection = AuthPassword_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Auth::kAuthTypeFieldNumber; +const int Auth::kAuthPasswdFieldNumber; +const int Auth::kAuthDataFieldNumber; +#endif // !_MSC_VER + +Auth::Auth() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Auth::InitAsDefaultInstance() { + auth_passwd_ = const_cast< ::xtreemfs::pbrpc::AuthPassword*>(&::xtreemfs::pbrpc::AuthPassword::default_instance()); +} + +Auth::Auth(const Auth& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Auth::SharedCtor() { + _cached_size_ = 0; + auth_type_ = 0; + auth_passwd_ = NULL; + auth_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Auth::~Auth() { + SharedDtor(); +} + +void Auth::SharedDtor() { + if (auth_data_ != &::google::protobuf::internal::kEmptyString) { + delete auth_data_; + } + if (this != default_instance_) { + delete auth_passwd_; + } +} + +void Auth::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Auth::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Auth_descriptor_; +} + +const Auth& Auth::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + return *default_instance_; +} + +Auth* Auth::default_instance_ = NULL; + +Auth* Auth::New() const { + return new Auth; +} + +void Auth::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + auth_type_ = 0; + if (has_auth_passwd()) { + if (auth_passwd_ != NULL) auth_passwd_->::xtreemfs::pbrpc::AuthPassword::Clear(); + } + if (has_auth_data()) { + if (auth_data_ != &::google::protobuf::internal::kEmptyString) { + auth_data_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Auth::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.AuthType auth_type = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::AuthType_IsValid(value)) { + set_auth_type(static_cast< ::xtreemfs::pbrpc::AuthType >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_auth_data; + break; + } + + // optional bytes auth_data = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_auth_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_auth_data())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_auth_passwd; + break; + } + + // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_auth_passwd: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_auth_passwd())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Auth::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.AuthType auth_type = 1; + if (has_auth_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->auth_type(), output); + } + + // optional bytes auth_data = 2; + if (has_auth_data()) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 2, this->auth_data(), output); + } + + // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3; + if (has_auth_passwd()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->auth_passwd(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Auth::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.AuthType auth_type = 1; + if (has_auth_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->auth_type(), target); + } + + // optional bytes auth_data = 2; + if (has_auth_data()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->auth_data(), target); + } + + // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3; + if (has_auth_passwd()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->auth_passwd(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Auth::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.AuthType auth_type = 1; + if (has_auth_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->auth_type()); + } + + // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3; + if (has_auth_passwd()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->auth_passwd()); + } + + // optional bytes auth_data = 2; + if (has_auth_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->auth_data()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Auth::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Auth* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Auth::MergeFrom(const Auth& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_auth_type()) { + set_auth_type(from.auth_type()); + } + if (from.has_auth_passwd()) { + mutable_auth_passwd()->::xtreemfs::pbrpc::AuthPassword::MergeFrom(from.auth_passwd()); + } + if (from.has_auth_data()) { + set_auth_data(from.auth_data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Auth::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Auth::CopyFrom(const Auth& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Auth::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_auth_passwd()) { + if (!this->auth_passwd().IsInitialized()) return false; + } + return true; +} + +void Auth::Swap(Auth* other) { + if (other != this) { + std::swap(auth_type_, other->auth_type_); + std::swap(auth_passwd_, other->auth_passwd_); + std::swap(auth_data_, other->auth_data_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Auth::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Auth_descriptor_; + metadata.reflection = Auth_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RPCHeader_RequestHeader::kInterfaceIdFieldNumber; +const int RPCHeader_RequestHeader::kProcIdFieldNumber; +const int RPCHeader_RequestHeader::kUserCredsFieldNumber; +const int RPCHeader_RequestHeader::kAuthDataFieldNumber; +#endif // !_MSC_VER + +RPCHeader_RequestHeader::RPCHeader_RequestHeader() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void RPCHeader_RequestHeader::InitAsDefaultInstance() { + user_creds_ = const_cast< ::xtreemfs::pbrpc::UserCredentials*>(&::xtreemfs::pbrpc::UserCredentials::default_instance()); + auth_data_ = const_cast< ::xtreemfs::pbrpc::Auth*>(&::xtreemfs::pbrpc::Auth::default_instance()); +} + +RPCHeader_RequestHeader::RPCHeader_RequestHeader(const RPCHeader_RequestHeader& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void RPCHeader_RequestHeader::SharedCtor() { + _cached_size_ = 0; + interface_id_ = 0u; + proc_id_ = 0u; + user_creds_ = NULL; + auth_data_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RPCHeader_RequestHeader::~RPCHeader_RequestHeader() { + SharedDtor(); +} + +void RPCHeader_RequestHeader::SharedDtor() { + if (this != default_instance_) { + delete user_creds_; + delete auth_data_; + } +} + +void RPCHeader_RequestHeader::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RPCHeader_RequestHeader::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RPCHeader_RequestHeader_descriptor_; +} + +const RPCHeader_RequestHeader& RPCHeader_RequestHeader::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + return *default_instance_; +} + +RPCHeader_RequestHeader* RPCHeader_RequestHeader::default_instance_ = NULL; + +RPCHeader_RequestHeader* RPCHeader_RequestHeader::New() const { + return new RPCHeader_RequestHeader; +} + +void RPCHeader_RequestHeader::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + interface_id_ = 0u; + proc_id_ = 0u; + if (has_user_creds()) { + if (user_creds_ != NULL) user_creds_->::xtreemfs::pbrpc::UserCredentials::Clear(); + } + if (has_auth_data()) { + if (auth_data_ != NULL) auth_data_->::xtreemfs::pbrpc::Auth::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RPCHeader_RequestHeader::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 interface_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &interface_id_))); + set_has_interface_id(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_proc_id; + break; + } + + // required fixed32 proc_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_proc_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &proc_id_))); + set_has_proc_id(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_user_creds; + break; + } + + // required .xtreemfs.pbrpc.UserCredentials user_creds = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_user_creds: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_user_creds())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_auth_data; + break; + } + + // required .xtreemfs.pbrpc.Auth auth_data = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_auth_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_auth_data())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void RPCHeader_RequestHeader::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 interface_id = 1; + if (has_interface_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->interface_id(), output); + } + + // required fixed32 proc_id = 2; + if (has_proc_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->proc_id(), output); + } + + // required .xtreemfs.pbrpc.UserCredentials user_creds = 3; + if (has_user_creds()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->user_creds(), output); + } + + // required .xtreemfs.pbrpc.Auth auth_data = 4; + if (has_auth_data()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->auth_data(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* RPCHeader_RequestHeader::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 interface_id = 1; + if (has_interface_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->interface_id(), target); + } + + // required fixed32 proc_id = 2; + if (has_proc_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->proc_id(), target); + } + + // required .xtreemfs.pbrpc.UserCredentials user_creds = 3; + if (has_user_creds()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->user_creds(), target); + } + + // required .xtreemfs.pbrpc.Auth auth_data = 4; + if (has_auth_data()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->auth_data(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int RPCHeader_RequestHeader::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 interface_id = 1; + if (has_interface_id()) { + total_size += 1 + 4; + } + + // required fixed32 proc_id = 2; + if (has_proc_id()) { + total_size += 1 + 4; + } + + // required .xtreemfs.pbrpc.UserCredentials user_creds = 3; + if (has_user_creds()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->user_creds()); + } + + // required .xtreemfs.pbrpc.Auth auth_data = 4; + if (has_auth_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->auth_data()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RPCHeader_RequestHeader::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RPCHeader_RequestHeader* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RPCHeader_RequestHeader::MergeFrom(const RPCHeader_RequestHeader& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_interface_id()) { + set_interface_id(from.interface_id()); + } + if (from.has_proc_id()) { + set_proc_id(from.proc_id()); + } + if (from.has_user_creds()) { + mutable_user_creds()->::xtreemfs::pbrpc::UserCredentials::MergeFrom(from.user_creds()); + } + if (from.has_auth_data()) { + mutable_auth_data()->::xtreemfs::pbrpc::Auth::MergeFrom(from.auth_data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RPCHeader_RequestHeader::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RPCHeader_RequestHeader::CopyFrom(const RPCHeader_RequestHeader& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RPCHeader_RequestHeader::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + if (has_user_creds()) { + if (!this->user_creds().IsInitialized()) return false; + } + if (has_auth_data()) { + if (!this->auth_data().IsInitialized()) return false; + } + return true; +} + +void RPCHeader_RequestHeader::Swap(RPCHeader_RequestHeader* other) { + if (other != this) { + std::swap(interface_id_, other->interface_id_); + std::swap(proc_id_, other->proc_id_); + std::swap(user_creds_, other->user_creds_); + std::swap(auth_data_, other->auth_data_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata RPCHeader_RequestHeader::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RPCHeader_RequestHeader_descriptor_; + metadata.reflection = RPCHeader_RequestHeader_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int RPCHeader_ErrorResponse::kErrorTypeFieldNumber; +const int RPCHeader_ErrorResponse::kPosixErrnoFieldNumber; +const int RPCHeader_ErrorResponse::kErrorMessageFieldNumber; +const int RPCHeader_ErrorResponse::kDebugInfoFieldNumber; +const int RPCHeader_ErrorResponse::kRedirectToServerUuidFieldNumber; +#endif // !_MSC_VER + +RPCHeader_ErrorResponse::RPCHeader_ErrorResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void RPCHeader_ErrorResponse::InitAsDefaultInstance() { +} + +RPCHeader_ErrorResponse::RPCHeader_ErrorResponse(const RPCHeader_ErrorResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void RPCHeader_ErrorResponse::SharedCtor() { + _cached_size_ = 0; + error_type_ = 1; + posix_errno_ = 9999; + error_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + debug_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + redirect_to_server_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RPCHeader_ErrorResponse::~RPCHeader_ErrorResponse() { + SharedDtor(); +} + +void RPCHeader_ErrorResponse::SharedDtor() { + if (error_message_ != &::google::protobuf::internal::kEmptyString) { + delete error_message_; + } + if (debug_info_ != &::google::protobuf::internal::kEmptyString) { + delete debug_info_; + } + if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete redirect_to_server_uuid_; + } + if (this != default_instance_) { + } +} + +void RPCHeader_ErrorResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RPCHeader_ErrorResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RPCHeader_ErrorResponse_descriptor_; +} + +const RPCHeader_ErrorResponse& RPCHeader_ErrorResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + return *default_instance_; +} + +RPCHeader_ErrorResponse* RPCHeader_ErrorResponse::default_instance_ = NULL; + +RPCHeader_ErrorResponse* RPCHeader_ErrorResponse::New() const { + return new RPCHeader_ErrorResponse; +} + +void RPCHeader_ErrorResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + error_type_ = 1; + posix_errno_ = 9999; + if (has_error_message()) { + if (error_message_ != &::google::protobuf::internal::kEmptyString) { + error_message_->clear(); + } + } + if (has_debug_info()) { + if (debug_info_ != &::google::protobuf::internal::kEmptyString) { + debug_info_->clear(); + } + } + if (has_redirect_to_server_uuid()) { + if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) { + redirect_to_server_uuid_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RPCHeader_ErrorResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.ErrorType error_type = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::ErrorType_IsValid(value)) { + set_error_type(static_cast< ::xtreemfs::pbrpc::ErrorType >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_posix_errno; + break; + } + + // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE]; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_posix_errno: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::POSIXErrno_IsValid(value)) { + set_posix_errno(static_cast< ::xtreemfs::pbrpc::POSIXErrno >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_error_message; + break; + } + + // optional string error_message = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_error_message: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_error_message())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->error_message().data(), this->error_message().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_debug_info; + break; + } + + // optional string debug_info = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_debug_info: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_debug_info())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->debug_info().data(), this->debug_info().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_redirect_to_server_uuid; + break; + } + + // optional string redirect_to_server_uuid = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_redirect_to_server_uuid: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_redirect_to_server_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void RPCHeader_ErrorResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.ErrorType error_type = 1; + if (has_error_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->error_type(), output); + } + + // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE]; + if (has_posix_errno()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->posix_errno(), output); + } + + // optional string error_message = 3; + if (has_error_message()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->error_message().data(), this->error_message().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->error_message(), output); + } + + // optional string debug_info = 4; + if (has_debug_info()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->debug_info().data(), this->debug_info().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->debug_info(), output); + } + + // optional string redirect_to_server_uuid = 5; + if (has_redirect_to_server_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 5, this->redirect_to_server_uuid(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* RPCHeader_ErrorResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.ErrorType error_type = 1; + if (has_error_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->error_type(), target); + } + + // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE]; + if (has_posix_errno()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->posix_errno(), target); + } + + // optional string error_message = 3; + if (has_error_message()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->error_message().data(), this->error_message().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->error_message(), target); + } + + // optional string debug_info = 4; + if (has_debug_info()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->debug_info().data(), this->debug_info().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->debug_info(), target); + } + + // optional string redirect_to_server_uuid = 5; + if (has_redirect_to_server_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->redirect_to_server_uuid(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int RPCHeader_ErrorResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.ErrorType error_type = 1; + if (has_error_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->error_type()); + } + + // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE]; + if (has_posix_errno()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->posix_errno()); + } + + // optional string error_message = 3; + if (has_error_message()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->error_message()); + } + + // optional string debug_info = 4; + if (has_debug_info()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->debug_info()); + } + + // optional string redirect_to_server_uuid = 5; + if (has_redirect_to_server_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->redirect_to_server_uuid()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RPCHeader_ErrorResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RPCHeader_ErrorResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RPCHeader_ErrorResponse::MergeFrom(const RPCHeader_ErrorResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_error_type()) { + set_error_type(from.error_type()); + } + if (from.has_posix_errno()) { + set_posix_errno(from.posix_errno()); + } + if (from.has_error_message()) { + set_error_message(from.error_message()); + } + if (from.has_debug_info()) { + set_debug_info(from.debug_info()); + } + if (from.has_redirect_to_server_uuid()) { + set_redirect_to_server_uuid(from.redirect_to_server_uuid()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RPCHeader_ErrorResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RPCHeader_ErrorResponse::CopyFrom(const RPCHeader_ErrorResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RPCHeader_ErrorResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void RPCHeader_ErrorResponse::Swap(RPCHeader_ErrorResponse* other) { + if (other != this) { + std::swap(error_type_, other->error_type_); + std::swap(posix_errno_, other->posix_errno_); + std::swap(error_message_, other->error_message_); + std::swap(debug_info_, other->debug_info_); + std::swap(redirect_to_server_uuid_, other->redirect_to_server_uuid_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata RPCHeader_ErrorResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RPCHeader_ErrorResponse_descriptor_; + metadata.reflection = RPCHeader_ErrorResponse_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int RPCHeader::kCallIdFieldNumber; +const int RPCHeader::kMessageTypeFieldNumber; +const int RPCHeader::kRequestHeaderFieldNumber; +const int RPCHeader::kErrorResponseFieldNumber; +#endif // !_MSC_VER + +RPCHeader::RPCHeader() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void RPCHeader::InitAsDefaultInstance() { + request_header_ = const_cast< ::xtreemfs::pbrpc::RPCHeader_RequestHeader*>(&::xtreemfs::pbrpc::RPCHeader_RequestHeader::default_instance()); + error_response_ = const_cast< ::xtreemfs::pbrpc::RPCHeader_ErrorResponse*>(&::xtreemfs::pbrpc::RPCHeader_ErrorResponse::default_instance()); +} + +RPCHeader::RPCHeader(const RPCHeader& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void RPCHeader::SharedCtor() { + _cached_size_ = 0; + call_id_ = 0u; + message_type_ = 0; + request_header_ = NULL; + error_response_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RPCHeader::~RPCHeader() { + SharedDtor(); +} + +void RPCHeader::SharedDtor() { + if (this != default_instance_) { + delete request_header_; + delete error_response_; + } +} + +void RPCHeader::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* RPCHeader::descriptor() { + protobuf_AssignDescriptorsOnce(); + return RPCHeader_descriptor_; +} + +const RPCHeader& RPCHeader::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + return *default_instance_; +} + +RPCHeader* RPCHeader::default_instance_ = NULL; + +RPCHeader* RPCHeader::New() const { + return new RPCHeader; +} + +void RPCHeader::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + call_id_ = 0u; + message_type_ = 0; + if (has_request_header()) { + if (request_header_ != NULL) request_header_->::xtreemfs::pbrpc::RPCHeader_RequestHeader::Clear(); + } + if (has_error_response()) { + if (error_response_ != NULL) error_response_->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool RPCHeader::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 call_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &call_id_))); + set_has_call_id(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_message_type; + break; + } + + // required .xtreemfs.pbrpc.MessageType message_type = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_message_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::MessageType_IsValid(value)) { + set_message_type(static_cast< ::xtreemfs::pbrpc::MessageType >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_request_header; + break; + } + + // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_request_header: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_request_header())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_error_response; + break; + } + + // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_error_response: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_error_response())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void RPCHeader::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 call_id = 1; + if (has_call_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->call_id(), output); + } + + // required .xtreemfs.pbrpc.MessageType message_type = 2; + if (has_message_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->message_type(), output); + } + + // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3; + if (has_request_header()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->request_header(), output); + } + + // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4; + if (has_error_response()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->error_response(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* RPCHeader::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 call_id = 1; + if (has_call_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->call_id(), target); + } + + // required .xtreemfs.pbrpc.MessageType message_type = 2; + if (has_message_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->message_type(), target); + } + + // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3; + if (has_request_header()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->request_header(), target); + } + + // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4; + if (has_error_response()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->error_response(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int RPCHeader::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 call_id = 1; + if (has_call_id()) { + total_size += 1 + 4; + } + + // required .xtreemfs.pbrpc.MessageType message_type = 2; + if (has_message_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->message_type()); + } + + // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3; + if (has_request_header()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->request_header()); + } + + // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4; + if (has_error_response()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->error_response()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RPCHeader::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const RPCHeader* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void RPCHeader::MergeFrom(const RPCHeader& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_call_id()) { + set_call_id(from.call_id()); + } + if (from.has_message_type()) { + set_message_type(from.message_type()); + } + if (from.has_request_header()) { + mutable_request_header()->::xtreemfs::pbrpc::RPCHeader_RequestHeader::MergeFrom(from.request_header()); + } + if (from.has_error_response()) { + mutable_error_response()->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::MergeFrom(from.error_response()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void RPCHeader::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RPCHeader::CopyFrom(const RPCHeader& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RPCHeader::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_request_header()) { + if (!this->request_header().IsInitialized()) return false; + } + if (has_error_response()) { + if (!this->error_response().IsInitialized()) return false; + } + return true; +} + +void RPCHeader::Swap(RPCHeader* other) { + if (other != this) { + std::swap(call_id_, other->call_id_); + std::swap(message_type_, other->message_type_); + std::swap(request_header_, other->request_header_); + std::swap(error_response_, other->error_response_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata RPCHeader::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = RPCHeader_descriptor_; + metadata.reflection = RPCHeader_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +// @@protoc_insertion_point(global_scope) diff --git a/cpp/generated/pbrpc/RPC.pb.h b/cpp/generated/pbrpc/RPC.pb.h new file mode 100644 index 0000000..6712497 --- /dev/null +++ b/cpp/generated/pbrpc/RPC.pb.h @@ -0,0 +1,1687 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: pbrpc/RPC.proto + +#ifndef PROTOBUF_pbrpc_2fRPC_2eproto__INCLUDED +#define PROTOBUF_pbrpc_2fRPC_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2005000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_pbrpc_2fRPC_2eproto(); +void protobuf_AssignDesc_pbrpc_2fRPC_2eproto(); +void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto(); + +class UserCredentials; +class AuthPassword; +class Auth; +class RPCHeader; +class RPCHeader_RequestHeader; +class RPCHeader_ErrorResponse; + +enum MessageType { + RPC_REQUEST = 0, + RPC_RESPONSE_SUCCESS = 1, + RPC_RESPONSE_ERROR = 2 +}; +bool MessageType_IsValid(int value); +const MessageType MessageType_MIN = RPC_REQUEST; +const MessageType MessageType_MAX = RPC_RESPONSE_ERROR; +const int MessageType_ARRAYSIZE = MessageType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* MessageType_descriptor(); +inline const ::std::string& MessageType_Name(MessageType value) { + return ::google::protobuf::internal::NameOfEnum( + MessageType_descriptor(), value); +} +inline bool MessageType_Parse( + const ::std::string& name, MessageType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + MessageType_descriptor(), name, value); +} +enum AuthType { + AUTH_NONE = 0, + AUTH_PASSWORD = 1 +}; +bool AuthType_IsValid(int value); +const AuthType AuthType_MIN = AUTH_NONE; +const AuthType AuthType_MAX = AUTH_PASSWORD; +const int AuthType_ARRAYSIZE = AuthType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* AuthType_descriptor(); +inline const ::std::string& AuthType_Name(AuthType value) { + return ::google::protobuf::internal::NameOfEnum( + AuthType_descriptor(), value); +} +inline bool AuthType_Parse( + const ::std::string& name, AuthType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + AuthType_descriptor(), name, value); +} +enum ErrorType { + INVALID_INTERFACE_ID = 1, + INVALID_PROC_ID = 2, + GARBAGE_ARGS = 3, + AUTH_FAILED = 4, + INTERNAL_SERVER_ERROR = 5, + ERRNO = 6, + REDIRECT = 7, + INVALID_VIEW = 8, + IO_ERROR = 100 +}; +bool ErrorType_IsValid(int value); +const ErrorType ErrorType_MIN = INVALID_INTERFACE_ID; +const ErrorType ErrorType_MAX = IO_ERROR; +const int ErrorType_ARRAYSIZE = ErrorType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ErrorType_descriptor(); +inline const ::std::string& ErrorType_Name(ErrorType value) { + return ::google::protobuf::internal::NameOfEnum( + ErrorType_descriptor(), value); +} +inline bool ErrorType_Parse( + const ::std::string& name, ErrorType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ErrorType_descriptor(), name, value); +} +enum POSIXErrno { + POSIX_ERROR_NONE = 9999, + POSIX_ERROR_EPERM = 1, + POSIX_ERROR_ENOENT = 2, + POSIX_ERROR_EINTR = 4, + POSIX_ERROR_EIO = 5, + POSIX_ERROR_EAGAIN = 11, + POSIX_ERROR_EACCES = 13, + POSIX_ERROR_EEXIST = 17, + POSIX_ERROR_EXDEV = 18, + POSIX_ERROR_ENODEV = 19, + POSIX_ERROR_ENOTDIR = 20, + POSIX_ERROR_EISDIR = 21, + POSIX_ERROR_EINVAL = 22, + POSIX_ERROR_ENOSPC = 28, + POSIX_ERROR_ENOTEMPTY = 39, + POSIX_ERROR_ENODATA = 61 +}; +bool POSIXErrno_IsValid(int value); +const POSIXErrno POSIXErrno_MIN = POSIX_ERROR_EPERM; +const POSIXErrno POSIXErrno_MAX = POSIX_ERROR_NONE; +const int POSIXErrno_ARRAYSIZE = POSIXErrno_MAX + 1; + +const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor(); +inline const ::std::string& POSIXErrno_Name(POSIXErrno value) { + return ::google::protobuf::internal::NameOfEnum( + POSIXErrno_descriptor(), value); +} +inline bool POSIXErrno_Parse( + const ::std::string& name, POSIXErrno* value) { + return ::google::protobuf::internal::ParseNamedEnum( + POSIXErrno_descriptor(), name, value); +} +// =================================================================== + +class UserCredentials : public ::google::protobuf::Message { + public: + UserCredentials(); + virtual ~UserCredentials(); + + UserCredentials(const UserCredentials& from); + + inline UserCredentials& operator=(const UserCredentials& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const UserCredentials& default_instance(); + + void Swap(UserCredentials* other); + + // implements Message ---------------------------------------------- + + UserCredentials* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const UserCredentials& from); + void MergeFrom(const UserCredentials& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string username = 1; + inline bool has_username() const; + inline void clear_username(); + static const int kUsernameFieldNumber = 1; + inline const ::std::string& username() const; + inline void set_username(const ::std::string& value); + inline void set_username(const char* value); + inline void set_username(const char* value, size_t size); + inline ::std::string* mutable_username(); + inline ::std::string* release_username(); + inline void set_allocated_username(::std::string* username); + + // repeated string groups = 2; + inline int groups_size() const; + inline void clear_groups(); + static const int kGroupsFieldNumber = 2; + inline const ::std::string& groups(int index) const; + inline ::std::string* mutable_groups(int index); + inline void set_groups(int index, const ::std::string& value); + inline void set_groups(int index, const char* value); + inline void set_groups(int index, const char* value, size_t size); + inline ::std::string* add_groups(); + inline void add_groups(const ::std::string& value); + inline void add_groups(const char* value); + inline void add_groups(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& groups() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_groups(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.UserCredentials) + private: + inline void set_has_username(); + inline void clear_has_username(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* username_; + ::google::protobuf::RepeatedPtrField< ::std::string> groups_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto(); + + void InitAsDefaultInstance(); + static UserCredentials* default_instance_; +}; +// ------------------------------------------------------------------- + +class AuthPassword : public ::google::protobuf::Message { + public: + AuthPassword(); + virtual ~AuthPassword(); + + AuthPassword(const AuthPassword& from); + + inline AuthPassword& operator=(const AuthPassword& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AuthPassword& default_instance(); + + void Swap(AuthPassword* other); + + // implements Message ---------------------------------------------- + + AuthPassword* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AuthPassword& from); + void MergeFrom(const AuthPassword& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string password = 1; + inline bool has_password() const; + inline void clear_password(); + static const int kPasswordFieldNumber = 1; + inline const ::std::string& password() const; + inline void set_password(const ::std::string& value); + inline void set_password(const char* value); + inline void set_password(const char* value, size_t size); + inline ::std::string* mutable_password(); + inline ::std::string* release_password(); + inline void set_allocated_password(::std::string* password); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.AuthPassword) + private: + inline void set_has_password(); + inline void clear_has_password(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* password_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto(); + + void InitAsDefaultInstance(); + static AuthPassword* default_instance_; +}; +// ------------------------------------------------------------------- + +class Auth : public ::google::protobuf::Message { + public: + Auth(); + virtual ~Auth(); + + Auth(const Auth& from); + + inline Auth& operator=(const Auth& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Auth& default_instance(); + + void Swap(Auth* other); + + // implements Message ---------------------------------------------- + + Auth* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Auth& from); + void MergeFrom(const Auth& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.AuthType auth_type = 1; + inline bool has_auth_type() const; + inline void clear_auth_type(); + static const int kAuthTypeFieldNumber = 1; + inline ::xtreemfs::pbrpc::AuthType auth_type() const; + inline void set_auth_type(::xtreemfs::pbrpc::AuthType value); + + // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3; + inline bool has_auth_passwd() const; + inline void clear_auth_passwd(); + static const int kAuthPasswdFieldNumber = 3; + inline const ::xtreemfs::pbrpc::AuthPassword& auth_passwd() const; + inline ::xtreemfs::pbrpc::AuthPassword* mutable_auth_passwd(); + inline ::xtreemfs::pbrpc::AuthPassword* release_auth_passwd(); + inline void set_allocated_auth_passwd(::xtreemfs::pbrpc::AuthPassword* auth_passwd); + + // optional bytes auth_data = 2; + inline bool has_auth_data() const; + inline void clear_auth_data(); + static const int kAuthDataFieldNumber = 2; + inline const ::std::string& auth_data() const; + inline void set_auth_data(const ::std::string& value); + inline void set_auth_data(const char* value); + inline void set_auth_data(const void* value, size_t size); + inline ::std::string* mutable_auth_data(); + inline ::std::string* release_auth_data(); + inline void set_allocated_auth_data(::std::string* auth_data); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Auth) + private: + inline void set_has_auth_type(); + inline void clear_has_auth_type(); + inline void set_has_auth_passwd(); + inline void clear_has_auth_passwd(); + inline void set_has_auth_data(); + inline void clear_has_auth_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::AuthPassword* auth_passwd_; + ::std::string* auth_data_; + int auth_type_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto(); + + void InitAsDefaultInstance(); + static Auth* default_instance_; +}; +// ------------------------------------------------------------------- + +class RPCHeader_RequestHeader : public ::google::protobuf::Message { + public: + RPCHeader_RequestHeader(); + virtual ~RPCHeader_RequestHeader(); + + RPCHeader_RequestHeader(const RPCHeader_RequestHeader& from); + + inline RPCHeader_RequestHeader& operator=(const RPCHeader_RequestHeader& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RPCHeader_RequestHeader& default_instance(); + + void Swap(RPCHeader_RequestHeader* other); + + // implements Message ---------------------------------------------- + + RPCHeader_RequestHeader* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RPCHeader_RequestHeader& from); + void MergeFrom(const RPCHeader_RequestHeader& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 interface_id = 1; + inline bool has_interface_id() const; + inline void clear_interface_id(); + static const int kInterfaceIdFieldNumber = 1; + inline ::google::protobuf::uint32 interface_id() const; + inline void set_interface_id(::google::protobuf::uint32 value); + + // required fixed32 proc_id = 2; + inline bool has_proc_id() const; + inline void clear_proc_id(); + static const int kProcIdFieldNumber = 2; + inline ::google::protobuf::uint32 proc_id() const; + inline void set_proc_id(::google::protobuf::uint32 value); + + // required .xtreemfs.pbrpc.UserCredentials user_creds = 3; + inline bool has_user_creds() const; + inline void clear_user_creds(); + static const int kUserCredsFieldNumber = 3; + inline const ::xtreemfs::pbrpc::UserCredentials& user_creds() const; + inline ::xtreemfs::pbrpc::UserCredentials* mutable_user_creds(); + inline ::xtreemfs::pbrpc::UserCredentials* release_user_creds(); + inline void set_allocated_user_creds(::xtreemfs::pbrpc::UserCredentials* user_creds); + + // required .xtreemfs.pbrpc.Auth auth_data = 4; + inline bool has_auth_data() const; + inline void clear_auth_data(); + static const int kAuthDataFieldNumber = 4; + inline const ::xtreemfs::pbrpc::Auth& auth_data() const; + inline ::xtreemfs::pbrpc::Auth* mutable_auth_data(); + inline ::xtreemfs::pbrpc::Auth* release_auth_data(); + inline void set_allocated_auth_data(::xtreemfs::pbrpc::Auth* auth_data); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.RPCHeader.RequestHeader) + private: + inline void set_has_interface_id(); + inline void clear_has_interface_id(); + inline void set_has_proc_id(); + inline void clear_has_proc_id(); + inline void set_has_user_creds(); + inline void clear_has_user_creds(); + inline void set_has_auth_data(); + inline void clear_has_auth_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 interface_id_; + ::google::protobuf::uint32 proc_id_; + ::xtreemfs::pbrpc::UserCredentials* user_creds_; + ::xtreemfs::pbrpc::Auth* auth_data_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto(); + + void InitAsDefaultInstance(); + static RPCHeader_RequestHeader* default_instance_; +}; +// ------------------------------------------------------------------- + +class RPCHeader_ErrorResponse : public ::google::protobuf::Message { + public: + RPCHeader_ErrorResponse(); + virtual ~RPCHeader_ErrorResponse(); + + RPCHeader_ErrorResponse(const RPCHeader_ErrorResponse& from); + + inline RPCHeader_ErrorResponse& operator=(const RPCHeader_ErrorResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RPCHeader_ErrorResponse& default_instance(); + + void Swap(RPCHeader_ErrorResponse* other); + + // implements Message ---------------------------------------------- + + RPCHeader_ErrorResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RPCHeader_ErrorResponse& from); + void MergeFrom(const RPCHeader_ErrorResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.ErrorType error_type = 1; + inline bool has_error_type() const; + inline void clear_error_type(); + static const int kErrorTypeFieldNumber = 1; + inline ::xtreemfs::pbrpc::ErrorType error_type() const; + inline void set_error_type(::xtreemfs::pbrpc::ErrorType value); + + // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE]; + inline bool has_posix_errno() const; + inline void clear_posix_errno(); + static const int kPosixErrnoFieldNumber = 2; + inline ::xtreemfs::pbrpc::POSIXErrno posix_errno() const; + inline void set_posix_errno(::xtreemfs::pbrpc::POSIXErrno value); + + // optional string error_message = 3; + inline bool has_error_message() const; + inline void clear_error_message(); + static const int kErrorMessageFieldNumber = 3; + inline const ::std::string& error_message() const; + inline void set_error_message(const ::std::string& value); + inline void set_error_message(const char* value); + inline void set_error_message(const char* value, size_t size); + inline ::std::string* mutable_error_message(); + inline ::std::string* release_error_message(); + inline void set_allocated_error_message(::std::string* error_message); + + // optional string debug_info = 4; + inline bool has_debug_info() const; + inline void clear_debug_info(); + static const int kDebugInfoFieldNumber = 4; + inline const ::std::string& debug_info() const; + inline void set_debug_info(const ::std::string& value); + inline void set_debug_info(const char* value); + inline void set_debug_info(const char* value, size_t size); + inline ::std::string* mutable_debug_info(); + inline ::std::string* release_debug_info(); + inline void set_allocated_debug_info(::std::string* debug_info); + + // optional string redirect_to_server_uuid = 5; + inline bool has_redirect_to_server_uuid() const; + inline void clear_redirect_to_server_uuid(); + static const int kRedirectToServerUuidFieldNumber = 5; + inline const ::std::string& redirect_to_server_uuid() const; + inline void set_redirect_to_server_uuid(const ::std::string& value); + inline void set_redirect_to_server_uuid(const char* value); + inline void set_redirect_to_server_uuid(const char* value, size_t size); + inline ::std::string* mutable_redirect_to_server_uuid(); + inline ::std::string* release_redirect_to_server_uuid(); + inline void set_allocated_redirect_to_server_uuid(::std::string* redirect_to_server_uuid); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.RPCHeader.ErrorResponse) + private: + inline void set_has_error_type(); + inline void clear_has_error_type(); + inline void set_has_posix_errno(); + inline void clear_has_posix_errno(); + inline void set_has_error_message(); + inline void clear_has_error_message(); + inline void set_has_debug_info(); + inline void clear_has_debug_info(); + inline void set_has_redirect_to_server_uuid(); + inline void clear_has_redirect_to_server_uuid(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + int error_type_; + int posix_errno_; + ::std::string* error_message_; + ::std::string* debug_info_; + ::std::string* redirect_to_server_uuid_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto(); + + void InitAsDefaultInstance(); + static RPCHeader_ErrorResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class RPCHeader : public ::google::protobuf::Message { + public: + RPCHeader(); + virtual ~RPCHeader(); + + RPCHeader(const RPCHeader& from); + + inline RPCHeader& operator=(const RPCHeader& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RPCHeader& default_instance(); + + void Swap(RPCHeader* other); + + // implements Message ---------------------------------------------- + + RPCHeader* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RPCHeader& from); + void MergeFrom(const RPCHeader& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef RPCHeader_RequestHeader RequestHeader; + typedef RPCHeader_ErrorResponse ErrorResponse; + + // accessors ------------------------------------------------------- + + // required fixed32 call_id = 1; + inline bool has_call_id() const; + inline void clear_call_id(); + static const int kCallIdFieldNumber = 1; + inline ::google::protobuf::uint32 call_id() const; + inline void set_call_id(::google::protobuf::uint32 value); + + // required .xtreemfs.pbrpc.MessageType message_type = 2; + inline bool has_message_type() const; + inline void clear_message_type(); + static const int kMessageTypeFieldNumber = 2; + inline ::xtreemfs::pbrpc::MessageType message_type() const; + inline void set_message_type(::xtreemfs::pbrpc::MessageType value); + + // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3; + inline bool has_request_header() const; + inline void clear_request_header(); + static const int kRequestHeaderFieldNumber = 3; + inline const ::xtreemfs::pbrpc::RPCHeader_RequestHeader& request_header() const; + inline ::xtreemfs::pbrpc::RPCHeader_RequestHeader* mutable_request_header(); + inline ::xtreemfs::pbrpc::RPCHeader_RequestHeader* release_request_header(); + inline void set_allocated_request_header(::xtreemfs::pbrpc::RPCHeader_RequestHeader* request_header); + + // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4; + inline bool has_error_response() const; + inline void clear_error_response(); + static const int kErrorResponseFieldNumber = 4; + inline const ::xtreemfs::pbrpc::RPCHeader_ErrorResponse& error_response() const; + inline ::xtreemfs::pbrpc::RPCHeader_ErrorResponse* mutable_error_response(); + inline ::xtreemfs::pbrpc::RPCHeader_ErrorResponse* release_error_response(); + inline void set_allocated_error_response(::xtreemfs::pbrpc::RPCHeader_ErrorResponse* error_response); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.RPCHeader) + private: + inline void set_has_call_id(); + inline void clear_has_call_id(); + inline void set_has_message_type(); + inline void clear_has_message_type(); + inline void set_has_request_header(); + inline void clear_has_request_header(); + inline void set_has_error_response(); + inline void clear_has_error_response(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 call_id_; + int message_type_; + ::xtreemfs::pbrpc::RPCHeader_RequestHeader* request_header_; + ::xtreemfs::pbrpc::RPCHeader_ErrorResponse* error_response_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_AssignDesc_pbrpc_2fRPC_2eproto(); + friend void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto(); + + void InitAsDefaultInstance(); + static RPCHeader* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// UserCredentials + +// required string username = 1; +inline bool UserCredentials::has_username() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UserCredentials::set_has_username() { + _has_bits_[0] |= 0x00000001u; +} +inline void UserCredentials::clear_has_username() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UserCredentials::clear_username() { + if (username_ != &::google::protobuf::internal::kEmptyString) { + username_->clear(); + } + clear_has_username(); +} +inline const ::std::string& UserCredentials::username() const { + return *username_; +} +inline void UserCredentials::set_username(const ::std::string& value) { + set_has_username(); + if (username_ == &::google::protobuf::internal::kEmptyString) { + username_ = new ::std::string; + } + username_->assign(value); +} +inline void UserCredentials::set_username(const char* value) { + set_has_username(); + if (username_ == &::google::protobuf::internal::kEmptyString) { + username_ = new ::std::string; + } + username_->assign(value); +} +inline void UserCredentials::set_username(const char* value, size_t size) { + set_has_username(); + if (username_ == &::google::protobuf::internal::kEmptyString) { + username_ = new ::std::string; + } + username_->assign(reinterpret_cast(value), size); +} +inline ::std::string* UserCredentials::mutable_username() { + set_has_username(); + if (username_ == &::google::protobuf::internal::kEmptyString) { + username_ = new ::std::string; + } + return username_; +} +inline ::std::string* UserCredentials::release_username() { + clear_has_username(); + if (username_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = username_; + username_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void UserCredentials::set_allocated_username(::std::string* username) { + if (username_ != &::google::protobuf::internal::kEmptyString) { + delete username_; + } + if (username) { + set_has_username(); + username_ = username; + } else { + clear_has_username(); + username_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// repeated string groups = 2; +inline int UserCredentials::groups_size() const { + return groups_.size(); +} +inline void UserCredentials::clear_groups() { + groups_.Clear(); +} +inline const ::std::string& UserCredentials::groups(int index) const { + return groups_.Get(index); +} +inline ::std::string* UserCredentials::mutable_groups(int index) { + return groups_.Mutable(index); +} +inline void UserCredentials::set_groups(int index, const ::std::string& value) { + groups_.Mutable(index)->assign(value); +} +inline void UserCredentials::set_groups(int index, const char* value) { + groups_.Mutable(index)->assign(value); +} +inline void UserCredentials::set_groups(int index, const char* value, size_t size) { + groups_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* UserCredentials::add_groups() { + return groups_.Add(); +} +inline void UserCredentials::add_groups(const ::std::string& value) { + groups_.Add()->assign(value); +} +inline void UserCredentials::add_groups(const char* value) { + groups_.Add()->assign(value); +} +inline void UserCredentials::add_groups(const char* value, size_t size) { + groups_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +UserCredentials::groups() const { + return groups_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +UserCredentials::mutable_groups() { + return &groups_; +} + +// ------------------------------------------------------------------- + +// AuthPassword + +// required string password = 1; +inline bool AuthPassword::has_password() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AuthPassword::set_has_password() { + _has_bits_[0] |= 0x00000001u; +} +inline void AuthPassword::clear_has_password() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AuthPassword::clear_password() { + if (password_ != &::google::protobuf::internal::kEmptyString) { + password_->clear(); + } + clear_has_password(); +} +inline const ::std::string& AuthPassword::password() const { + return *password_; +} +inline void AuthPassword::set_password(const ::std::string& value) { + set_has_password(); + if (password_ == &::google::protobuf::internal::kEmptyString) { + password_ = new ::std::string; + } + password_->assign(value); +} +inline void AuthPassword::set_password(const char* value) { + set_has_password(); + if (password_ == &::google::protobuf::internal::kEmptyString) { + password_ = new ::std::string; + } + password_->assign(value); +} +inline void AuthPassword::set_password(const char* value, size_t size) { + set_has_password(); + if (password_ == &::google::protobuf::internal::kEmptyString) { + password_ = new ::std::string; + } + password_->assign(reinterpret_cast(value), size); +} +inline ::std::string* AuthPassword::mutable_password() { + set_has_password(); + if (password_ == &::google::protobuf::internal::kEmptyString) { + password_ = new ::std::string; + } + return password_; +} +inline ::std::string* AuthPassword::release_password() { + clear_has_password(); + if (password_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = password_; + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void AuthPassword::set_allocated_password(::std::string* password) { + if (password_ != &::google::protobuf::internal::kEmptyString) { + delete password_; + } + if (password) { + set_has_password(); + password_ = password; + } else { + clear_has_password(); + password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// Auth + +// required .xtreemfs.pbrpc.AuthType auth_type = 1; +inline bool Auth::has_auth_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Auth::set_has_auth_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void Auth::clear_has_auth_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Auth::clear_auth_type() { + auth_type_ = 0; + clear_has_auth_type(); +} +inline ::xtreemfs::pbrpc::AuthType Auth::auth_type() const { + return static_cast< ::xtreemfs::pbrpc::AuthType >(auth_type_); +} +inline void Auth::set_auth_type(::xtreemfs::pbrpc::AuthType value) { + assert(::xtreemfs::pbrpc::AuthType_IsValid(value)); + set_has_auth_type(); + auth_type_ = value; +} + +// optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3; +inline bool Auth::has_auth_passwd() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Auth::set_has_auth_passwd() { + _has_bits_[0] |= 0x00000002u; +} +inline void Auth::clear_has_auth_passwd() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Auth::clear_auth_passwd() { + if (auth_passwd_ != NULL) auth_passwd_->::xtreemfs::pbrpc::AuthPassword::Clear(); + clear_has_auth_passwd(); +} +inline const ::xtreemfs::pbrpc::AuthPassword& Auth::auth_passwd() const { + return auth_passwd_ != NULL ? *auth_passwd_ : *default_instance_->auth_passwd_; +} +inline ::xtreemfs::pbrpc::AuthPassword* Auth::mutable_auth_passwd() { + set_has_auth_passwd(); + if (auth_passwd_ == NULL) auth_passwd_ = new ::xtreemfs::pbrpc::AuthPassword; + return auth_passwd_; +} +inline ::xtreemfs::pbrpc::AuthPassword* Auth::release_auth_passwd() { + clear_has_auth_passwd(); + ::xtreemfs::pbrpc::AuthPassword* temp = auth_passwd_; + auth_passwd_ = NULL; + return temp; +} +inline void Auth::set_allocated_auth_passwd(::xtreemfs::pbrpc::AuthPassword* auth_passwd) { + delete auth_passwd_; + auth_passwd_ = auth_passwd; + if (auth_passwd) { + set_has_auth_passwd(); + } else { + clear_has_auth_passwd(); + } +} + +// optional bytes auth_data = 2; +inline bool Auth::has_auth_data() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Auth::set_has_auth_data() { + _has_bits_[0] |= 0x00000004u; +} +inline void Auth::clear_has_auth_data() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Auth::clear_auth_data() { + if (auth_data_ != &::google::protobuf::internal::kEmptyString) { + auth_data_->clear(); + } + clear_has_auth_data(); +} +inline const ::std::string& Auth::auth_data() const { + return *auth_data_; +} +inline void Auth::set_auth_data(const ::std::string& value) { + set_has_auth_data(); + if (auth_data_ == &::google::protobuf::internal::kEmptyString) { + auth_data_ = new ::std::string; + } + auth_data_->assign(value); +} +inline void Auth::set_auth_data(const char* value) { + set_has_auth_data(); + if (auth_data_ == &::google::protobuf::internal::kEmptyString) { + auth_data_ = new ::std::string; + } + auth_data_->assign(value); +} +inline void Auth::set_auth_data(const void* value, size_t size) { + set_has_auth_data(); + if (auth_data_ == &::google::protobuf::internal::kEmptyString) { + auth_data_ = new ::std::string; + } + auth_data_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Auth::mutable_auth_data() { + set_has_auth_data(); + if (auth_data_ == &::google::protobuf::internal::kEmptyString) { + auth_data_ = new ::std::string; + } + return auth_data_; +} +inline ::std::string* Auth::release_auth_data() { + clear_has_auth_data(); + if (auth_data_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = auth_data_; + auth_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Auth::set_allocated_auth_data(::std::string* auth_data) { + if (auth_data_ != &::google::protobuf::internal::kEmptyString) { + delete auth_data_; + } + if (auth_data) { + set_has_auth_data(); + auth_data_ = auth_data; + } else { + clear_has_auth_data(); + auth_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// RPCHeader_RequestHeader + +// required fixed32 interface_id = 1; +inline bool RPCHeader_RequestHeader::has_interface_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RPCHeader_RequestHeader::set_has_interface_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void RPCHeader_RequestHeader::clear_has_interface_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RPCHeader_RequestHeader::clear_interface_id() { + interface_id_ = 0u; + clear_has_interface_id(); +} +inline ::google::protobuf::uint32 RPCHeader_RequestHeader::interface_id() const { + return interface_id_; +} +inline void RPCHeader_RequestHeader::set_interface_id(::google::protobuf::uint32 value) { + set_has_interface_id(); + interface_id_ = value; +} + +// required fixed32 proc_id = 2; +inline bool RPCHeader_RequestHeader::has_proc_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RPCHeader_RequestHeader::set_has_proc_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void RPCHeader_RequestHeader::clear_has_proc_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RPCHeader_RequestHeader::clear_proc_id() { + proc_id_ = 0u; + clear_has_proc_id(); +} +inline ::google::protobuf::uint32 RPCHeader_RequestHeader::proc_id() const { + return proc_id_; +} +inline void RPCHeader_RequestHeader::set_proc_id(::google::protobuf::uint32 value) { + set_has_proc_id(); + proc_id_ = value; +} + +// required .xtreemfs.pbrpc.UserCredentials user_creds = 3; +inline bool RPCHeader_RequestHeader::has_user_creds() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RPCHeader_RequestHeader::set_has_user_creds() { + _has_bits_[0] |= 0x00000004u; +} +inline void RPCHeader_RequestHeader::clear_has_user_creds() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RPCHeader_RequestHeader::clear_user_creds() { + if (user_creds_ != NULL) user_creds_->::xtreemfs::pbrpc::UserCredentials::Clear(); + clear_has_user_creds(); +} +inline const ::xtreemfs::pbrpc::UserCredentials& RPCHeader_RequestHeader::user_creds() const { + return user_creds_ != NULL ? *user_creds_ : *default_instance_->user_creds_; +} +inline ::xtreemfs::pbrpc::UserCredentials* RPCHeader_RequestHeader::mutable_user_creds() { + set_has_user_creds(); + if (user_creds_ == NULL) user_creds_ = new ::xtreemfs::pbrpc::UserCredentials; + return user_creds_; +} +inline ::xtreemfs::pbrpc::UserCredentials* RPCHeader_RequestHeader::release_user_creds() { + clear_has_user_creds(); + ::xtreemfs::pbrpc::UserCredentials* temp = user_creds_; + user_creds_ = NULL; + return temp; +} +inline void RPCHeader_RequestHeader::set_allocated_user_creds(::xtreemfs::pbrpc::UserCredentials* user_creds) { + delete user_creds_; + user_creds_ = user_creds; + if (user_creds) { + set_has_user_creds(); + } else { + clear_has_user_creds(); + } +} + +// required .xtreemfs.pbrpc.Auth auth_data = 4; +inline bool RPCHeader_RequestHeader::has_auth_data() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void RPCHeader_RequestHeader::set_has_auth_data() { + _has_bits_[0] |= 0x00000008u; +} +inline void RPCHeader_RequestHeader::clear_has_auth_data() { + _has_bits_[0] &= ~0x00000008u; +} +inline void RPCHeader_RequestHeader::clear_auth_data() { + if (auth_data_ != NULL) auth_data_->::xtreemfs::pbrpc::Auth::Clear(); + clear_has_auth_data(); +} +inline const ::xtreemfs::pbrpc::Auth& RPCHeader_RequestHeader::auth_data() const { + return auth_data_ != NULL ? *auth_data_ : *default_instance_->auth_data_; +} +inline ::xtreemfs::pbrpc::Auth* RPCHeader_RequestHeader::mutable_auth_data() { + set_has_auth_data(); + if (auth_data_ == NULL) auth_data_ = new ::xtreemfs::pbrpc::Auth; + return auth_data_; +} +inline ::xtreemfs::pbrpc::Auth* RPCHeader_RequestHeader::release_auth_data() { + clear_has_auth_data(); + ::xtreemfs::pbrpc::Auth* temp = auth_data_; + auth_data_ = NULL; + return temp; +} +inline void RPCHeader_RequestHeader::set_allocated_auth_data(::xtreemfs::pbrpc::Auth* auth_data) { + delete auth_data_; + auth_data_ = auth_data; + if (auth_data) { + set_has_auth_data(); + } else { + clear_has_auth_data(); + } +} + +// ------------------------------------------------------------------- + +// RPCHeader_ErrorResponse + +// required .xtreemfs.pbrpc.ErrorType error_type = 1; +inline bool RPCHeader_ErrorResponse::has_error_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RPCHeader_ErrorResponse::set_has_error_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void RPCHeader_ErrorResponse::clear_has_error_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RPCHeader_ErrorResponse::clear_error_type() { + error_type_ = 1; + clear_has_error_type(); +} +inline ::xtreemfs::pbrpc::ErrorType RPCHeader_ErrorResponse::error_type() const { + return static_cast< ::xtreemfs::pbrpc::ErrorType >(error_type_); +} +inline void RPCHeader_ErrorResponse::set_error_type(::xtreemfs::pbrpc::ErrorType value) { + assert(::xtreemfs::pbrpc::ErrorType_IsValid(value)); + set_has_error_type(); + error_type_ = value; +} + +// optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE]; +inline bool RPCHeader_ErrorResponse::has_posix_errno() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RPCHeader_ErrorResponse::set_has_posix_errno() { + _has_bits_[0] |= 0x00000002u; +} +inline void RPCHeader_ErrorResponse::clear_has_posix_errno() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RPCHeader_ErrorResponse::clear_posix_errno() { + posix_errno_ = 9999; + clear_has_posix_errno(); +} +inline ::xtreemfs::pbrpc::POSIXErrno RPCHeader_ErrorResponse::posix_errno() const { + return static_cast< ::xtreemfs::pbrpc::POSIXErrno >(posix_errno_); +} +inline void RPCHeader_ErrorResponse::set_posix_errno(::xtreemfs::pbrpc::POSIXErrno value) { + assert(::xtreemfs::pbrpc::POSIXErrno_IsValid(value)); + set_has_posix_errno(); + posix_errno_ = value; +} + +// optional string error_message = 3; +inline bool RPCHeader_ErrorResponse::has_error_message() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RPCHeader_ErrorResponse::set_has_error_message() { + _has_bits_[0] |= 0x00000004u; +} +inline void RPCHeader_ErrorResponse::clear_has_error_message() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RPCHeader_ErrorResponse::clear_error_message() { + if (error_message_ != &::google::protobuf::internal::kEmptyString) { + error_message_->clear(); + } + clear_has_error_message(); +} +inline const ::std::string& RPCHeader_ErrorResponse::error_message() const { + return *error_message_; +} +inline void RPCHeader_ErrorResponse::set_error_message(const ::std::string& value) { + set_has_error_message(); + if (error_message_ == &::google::protobuf::internal::kEmptyString) { + error_message_ = new ::std::string; + } + error_message_->assign(value); +} +inline void RPCHeader_ErrorResponse::set_error_message(const char* value) { + set_has_error_message(); + if (error_message_ == &::google::protobuf::internal::kEmptyString) { + error_message_ = new ::std::string; + } + error_message_->assign(value); +} +inline void RPCHeader_ErrorResponse::set_error_message(const char* value, size_t size) { + set_has_error_message(); + if (error_message_ == &::google::protobuf::internal::kEmptyString) { + error_message_ = new ::std::string; + } + error_message_->assign(reinterpret_cast(value), size); +} +inline ::std::string* RPCHeader_ErrorResponse::mutable_error_message() { + set_has_error_message(); + if (error_message_ == &::google::protobuf::internal::kEmptyString) { + error_message_ = new ::std::string; + } + return error_message_; +} +inline ::std::string* RPCHeader_ErrorResponse::release_error_message() { + clear_has_error_message(); + if (error_message_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = error_message_; + error_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void RPCHeader_ErrorResponse::set_allocated_error_message(::std::string* error_message) { + if (error_message_ != &::google::protobuf::internal::kEmptyString) { + delete error_message_; + } + if (error_message) { + set_has_error_message(); + error_message_ = error_message; + } else { + clear_has_error_message(); + error_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string debug_info = 4; +inline bool RPCHeader_ErrorResponse::has_debug_info() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void RPCHeader_ErrorResponse::set_has_debug_info() { + _has_bits_[0] |= 0x00000008u; +} +inline void RPCHeader_ErrorResponse::clear_has_debug_info() { + _has_bits_[0] &= ~0x00000008u; +} +inline void RPCHeader_ErrorResponse::clear_debug_info() { + if (debug_info_ != &::google::protobuf::internal::kEmptyString) { + debug_info_->clear(); + } + clear_has_debug_info(); +} +inline const ::std::string& RPCHeader_ErrorResponse::debug_info() const { + return *debug_info_; +} +inline void RPCHeader_ErrorResponse::set_debug_info(const ::std::string& value) { + set_has_debug_info(); + if (debug_info_ == &::google::protobuf::internal::kEmptyString) { + debug_info_ = new ::std::string; + } + debug_info_->assign(value); +} +inline void RPCHeader_ErrorResponse::set_debug_info(const char* value) { + set_has_debug_info(); + if (debug_info_ == &::google::protobuf::internal::kEmptyString) { + debug_info_ = new ::std::string; + } + debug_info_->assign(value); +} +inline void RPCHeader_ErrorResponse::set_debug_info(const char* value, size_t size) { + set_has_debug_info(); + if (debug_info_ == &::google::protobuf::internal::kEmptyString) { + debug_info_ = new ::std::string; + } + debug_info_->assign(reinterpret_cast(value), size); +} +inline ::std::string* RPCHeader_ErrorResponse::mutable_debug_info() { + set_has_debug_info(); + if (debug_info_ == &::google::protobuf::internal::kEmptyString) { + debug_info_ = new ::std::string; + } + return debug_info_; +} +inline ::std::string* RPCHeader_ErrorResponse::release_debug_info() { + clear_has_debug_info(); + if (debug_info_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = debug_info_; + debug_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void RPCHeader_ErrorResponse::set_allocated_debug_info(::std::string* debug_info) { + if (debug_info_ != &::google::protobuf::internal::kEmptyString) { + delete debug_info_; + } + if (debug_info) { + set_has_debug_info(); + debug_info_ = debug_info; + } else { + clear_has_debug_info(); + debug_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string redirect_to_server_uuid = 5; +inline bool RPCHeader_ErrorResponse::has_redirect_to_server_uuid() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void RPCHeader_ErrorResponse::set_has_redirect_to_server_uuid() { + _has_bits_[0] |= 0x00000010u; +} +inline void RPCHeader_ErrorResponse::clear_has_redirect_to_server_uuid() { + _has_bits_[0] &= ~0x00000010u; +} +inline void RPCHeader_ErrorResponse::clear_redirect_to_server_uuid() { + if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) { + redirect_to_server_uuid_->clear(); + } + clear_has_redirect_to_server_uuid(); +} +inline const ::std::string& RPCHeader_ErrorResponse::redirect_to_server_uuid() const { + return *redirect_to_server_uuid_; +} +inline void RPCHeader_ErrorResponse::set_redirect_to_server_uuid(const ::std::string& value) { + set_has_redirect_to_server_uuid(); + if (redirect_to_server_uuid_ == &::google::protobuf::internal::kEmptyString) { + redirect_to_server_uuid_ = new ::std::string; + } + redirect_to_server_uuid_->assign(value); +} +inline void RPCHeader_ErrorResponse::set_redirect_to_server_uuid(const char* value) { + set_has_redirect_to_server_uuid(); + if (redirect_to_server_uuid_ == &::google::protobuf::internal::kEmptyString) { + redirect_to_server_uuid_ = new ::std::string; + } + redirect_to_server_uuid_->assign(value); +} +inline void RPCHeader_ErrorResponse::set_redirect_to_server_uuid(const char* value, size_t size) { + set_has_redirect_to_server_uuid(); + if (redirect_to_server_uuid_ == &::google::protobuf::internal::kEmptyString) { + redirect_to_server_uuid_ = new ::std::string; + } + redirect_to_server_uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* RPCHeader_ErrorResponse::mutable_redirect_to_server_uuid() { + set_has_redirect_to_server_uuid(); + if (redirect_to_server_uuid_ == &::google::protobuf::internal::kEmptyString) { + redirect_to_server_uuid_ = new ::std::string; + } + return redirect_to_server_uuid_; +} +inline ::std::string* RPCHeader_ErrorResponse::release_redirect_to_server_uuid() { + clear_has_redirect_to_server_uuid(); + if (redirect_to_server_uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = redirect_to_server_uuid_; + redirect_to_server_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void RPCHeader_ErrorResponse::set_allocated_redirect_to_server_uuid(::std::string* redirect_to_server_uuid) { + if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete redirect_to_server_uuid_; + } + if (redirect_to_server_uuid) { + set_has_redirect_to_server_uuid(); + redirect_to_server_uuid_ = redirect_to_server_uuid; + } else { + clear_has_redirect_to_server_uuid(); + redirect_to_server_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// RPCHeader + +// required fixed32 call_id = 1; +inline bool RPCHeader::has_call_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RPCHeader::set_has_call_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void RPCHeader::clear_has_call_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RPCHeader::clear_call_id() { + call_id_ = 0u; + clear_has_call_id(); +} +inline ::google::protobuf::uint32 RPCHeader::call_id() const { + return call_id_; +} +inline void RPCHeader::set_call_id(::google::protobuf::uint32 value) { + set_has_call_id(); + call_id_ = value; +} + +// required .xtreemfs.pbrpc.MessageType message_type = 2; +inline bool RPCHeader::has_message_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RPCHeader::set_has_message_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void RPCHeader::clear_has_message_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RPCHeader::clear_message_type() { + message_type_ = 0; + clear_has_message_type(); +} +inline ::xtreemfs::pbrpc::MessageType RPCHeader::message_type() const { + return static_cast< ::xtreemfs::pbrpc::MessageType >(message_type_); +} +inline void RPCHeader::set_message_type(::xtreemfs::pbrpc::MessageType value) { + assert(::xtreemfs::pbrpc::MessageType_IsValid(value)); + set_has_message_type(); + message_type_ = value; +} + +// optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3; +inline bool RPCHeader::has_request_header() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RPCHeader::set_has_request_header() { + _has_bits_[0] |= 0x00000004u; +} +inline void RPCHeader::clear_has_request_header() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RPCHeader::clear_request_header() { + if (request_header_ != NULL) request_header_->::xtreemfs::pbrpc::RPCHeader_RequestHeader::Clear(); + clear_has_request_header(); +} +inline const ::xtreemfs::pbrpc::RPCHeader_RequestHeader& RPCHeader::request_header() const { + return request_header_ != NULL ? *request_header_ : *default_instance_->request_header_; +} +inline ::xtreemfs::pbrpc::RPCHeader_RequestHeader* RPCHeader::mutable_request_header() { + set_has_request_header(); + if (request_header_ == NULL) request_header_ = new ::xtreemfs::pbrpc::RPCHeader_RequestHeader; + return request_header_; +} +inline ::xtreemfs::pbrpc::RPCHeader_RequestHeader* RPCHeader::release_request_header() { + clear_has_request_header(); + ::xtreemfs::pbrpc::RPCHeader_RequestHeader* temp = request_header_; + request_header_ = NULL; + return temp; +} +inline void RPCHeader::set_allocated_request_header(::xtreemfs::pbrpc::RPCHeader_RequestHeader* request_header) { + delete request_header_; + request_header_ = request_header; + if (request_header) { + set_has_request_header(); + } else { + clear_has_request_header(); + } +} + +// optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4; +inline bool RPCHeader::has_error_response() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void RPCHeader::set_has_error_response() { + _has_bits_[0] |= 0x00000008u; +} +inline void RPCHeader::clear_has_error_response() { + _has_bits_[0] &= ~0x00000008u; +} +inline void RPCHeader::clear_error_response() { + if (error_response_ != NULL) error_response_->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::Clear(); + clear_has_error_response(); +} +inline const ::xtreemfs::pbrpc::RPCHeader_ErrorResponse& RPCHeader::error_response() const { + return error_response_ != NULL ? *error_response_ : *default_instance_->error_response_; +} +inline ::xtreemfs::pbrpc::RPCHeader_ErrorResponse* RPCHeader::mutable_error_response() { + set_has_error_response(); + if (error_response_ == NULL) error_response_ = new ::xtreemfs::pbrpc::RPCHeader_ErrorResponse; + return error_response_; +} +inline ::xtreemfs::pbrpc::RPCHeader_ErrorResponse* RPCHeader::release_error_response() { + clear_has_error_response(); + ::xtreemfs::pbrpc::RPCHeader_ErrorResponse* temp = error_response_; + error_response_ = NULL; + return temp; +} +inline void RPCHeader::set_allocated_error_response(::xtreemfs::pbrpc::RPCHeader_ErrorResponse* error_response) { + delete error_response_; + error_response_ = error_response; + if (error_response) { + set_has_error_response(); + } else { + clear_has_error_response(); + } +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::MessageType>() { + return ::xtreemfs::pbrpc::MessageType_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::AuthType>() { + return ::xtreemfs::pbrpc::AuthType_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::ErrorType>() { + return ::xtreemfs::pbrpc::ErrorType_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::POSIXErrno>() { + return ::xtreemfs::pbrpc::POSIXErrno_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_pbrpc_2fRPC_2eproto__INCLUDED diff --git a/cpp/generated/xtreemfs/DIR.pb.cc b/cpp/generated/xtreemfs/DIR.pb.cc new file mode 100644 index 0000000..0fe7bb2 --- /dev/null +++ b/cpp/generated/xtreemfs/DIR.pb.cc @@ -0,0 +1,5586 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: xtreemfs/DIR.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "xtreemfs/DIR.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +namespace { + +const ::google::protobuf::Descriptor* AddressMapping_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AddressMapping_reflection_ = NULL; +const ::google::protobuf::Descriptor* AddressMappingSet_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AddressMappingSet_reflection_ = NULL; +const ::google::protobuf::Descriptor* DirService_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DirService_reflection_ = NULL; +const ::google::protobuf::Descriptor* ServiceDataMap_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ServiceDataMap_reflection_ = NULL; +const ::google::protobuf::Descriptor* Service_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Service_reflection_ = NULL; +const ::google::protobuf::Descriptor* ServiceSet_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ServiceSet_reflection_ = NULL; +const ::google::protobuf::Descriptor* Configuration_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Configuration_reflection_ = NULL; +const ::google::protobuf::Descriptor* addressMappingGetRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + addressMappingGetRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* addressMappingGetResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + addressMappingGetResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* addressMappingSetResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + addressMappingSetResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* globalTimeSGetResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + globalTimeSGetResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* serviceDeregisterRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + serviceDeregisterRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* serviceGetByNameRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + serviceGetByNameRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* serviceGetByUUIDRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + serviceGetByUUIDRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* serviceGetByTypeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + serviceGetByTypeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* serviceRegisterRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + serviceRegisterRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* serviceRegisterResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + serviceRegisterResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* configurationGetRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + configurationGetRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* configurationSetResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + configurationSetResponse_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* ServiceType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto() { + protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "xtreemfs/DIR.proto"); + GOOGLE_CHECK(file != NULL); + AddressMapping_descriptor_ = file->message_type(0); + static const int AddressMapping_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, uuid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, protocol_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, address_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, port_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, match_network_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, ttl_s_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, uri_), + }; + AddressMapping_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AddressMapping_descriptor_, + AddressMapping::default_instance_, + AddressMapping_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AddressMapping)); + AddressMappingSet_descriptor_ = file->message_type(1); + static const int AddressMappingSet_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, mappings_), + }; + AddressMappingSet_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AddressMappingSet_descriptor_, + AddressMappingSet::default_instance_, + AddressMappingSet_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AddressMappingSet)); + DirService_descriptor_ = file->message_type(2); + static const int DirService_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, address_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, port_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, protocol_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, interface_version_), + }; + DirService_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + DirService_descriptor_, + DirService::default_instance_, + DirService_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(DirService)); + ServiceDataMap_descriptor_ = file->message_type(3); + static const int ServiceDataMap_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, data_), + }; + ServiceDataMap_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ServiceDataMap_descriptor_, + ServiceDataMap::default_instance_, + ServiceDataMap_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ServiceDataMap)); + Service_descriptor_ = file->message_type(4); + static const int Service_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, uuid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, last_updated_s_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, data_), + }; + Service_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Service_descriptor_, + Service::default_instance_, + Service_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Service)); + ServiceSet_descriptor_ = file->message_type(5); + static const int ServiceSet_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, services_), + }; + ServiceSet_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ServiceSet_descriptor_, + ServiceSet::default_instance_, + ServiceSet_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ServiceSet)); + Configuration_descriptor_ = file->message_type(6); + static const int Configuration_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, uuid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, parameter_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, version_), + }; + Configuration_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Configuration_descriptor_, + Configuration::default_instance_, + Configuration_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Configuration)); + addressMappingGetRequest_descriptor_ = file->message_type(7); + static const int addressMappingGetRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, uuid_), + }; + addressMappingGetRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + addressMappingGetRequest_descriptor_, + addressMappingGetRequest::default_instance_, + addressMappingGetRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(addressMappingGetRequest)); + addressMappingGetResponse_descriptor_ = file->message_type(8); + static const int addressMappingGetResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, result_), + }; + addressMappingGetResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + addressMappingGetResponse_descriptor_, + addressMappingGetResponse::default_instance_, + addressMappingGetResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(addressMappingGetResponse)); + addressMappingSetResponse_descriptor_ = file->message_type(9); + static const int addressMappingSetResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, new_version_), + }; + addressMappingSetResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + addressMappingSetResponse_descriptor_, + addressMappingSetResponse::default_instance_, + addressMappingSetResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(addressMappingSetResponse)); + globalTimeSGetResponse_descriptor_ = file->message_type(10); + static const int globalTimeSGetResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, time_in_seconds_), + }; + globalTimeSGetResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + globalTimeSGetResponse_descriptor_, + globalTimeSGetResponse::default_instance_, + globalTimeSGetResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(globalTimeSGetResponse)); + serviceDeregisterRequest_descriptor_ = file->message_type(11); + static const int serviceDeregisterRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, uuid_), + }; + serviceDeregisterRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + serviceDeregisterRequest_descriptor_, + serviceDeregisterRequest::default_instance_, + serviceDeregisterRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(serviceDeregisterRequest)); + serviceGetByNameRequest_descriptor_ = file->message_type(12); + static const int serviceGetByNameRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, name_), + }; + serviceGetByNameRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + serviceGetByNameRequest_descriptor_, + serviceGetByNameRequest::default_instance_, + serviceGetByNameRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(serviceGetByNameRequest)); + serviceGetByUUIDRequest_descriptor_ = file->message_type(13); + static const int serviceGetByUUIDRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, name_), + }; + serviceGetByUUIDRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + serviceGetByUUIDRequest_descriptor_, + serviceGetByUUIDRequest::default_instance_, + serviceGetByUUIDRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(serviceGetByUUIDRequest)); + serviceGetByTypeRequest_descriptor_ = file->message_type(14); + static const int serviceGetByTypeRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, type_), + }; + serviceGetByTypeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + serviceGetByTypeRequest_descriptor_, + serviceGetByTypeRequest::default_instance_, + serviceGetByTypeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(serviceGetByTypeRequest)); + serviceRegisterRequest_descriptor_ = file->message_type(15); + static const int serviceRegisterRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, service_), + }; + serviceRegisterRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + serviceRegisterRequest_descriptor_, + serviceRegisterRequest::default_instance_, + serviceRegisterRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(serviceRegisterRequest)); + serviceRegisterResponse_descriptor_ = file->message_type(16); + static const int serviceRegisterResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, new_version_), + }; + serviceRegisterResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + serviceRegisterResponse_descriptor_, + serviceRegisterResponse::default_instance_, + serviceRegisterResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(serviceRegisterResponse)); + configurationGetRequest_descriptor_ = file->message_type(17); + static const int configurationGetRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, uuid_), + }; + configurationGetRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + configurationGetRequest_descriptor_, + configurationGetRequest::default_instance_, + configurationGetRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(configurationGetRequest)); + configurationSetResponse_descriptor_ = file->message_type(18); + static const int configurationSetResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, new_version_), + }; + configurationSetResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + configurationSetResponse_descriptor_, + configurationSetResponse::default_instance_, + configurationSetResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(configurationSetResponse)); + ServiceType_descriptor_ = file->enum_type(0); + ServiceStatus_descriptor_ = file->enum_type(1); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_xtreemfs_2fDIR_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AddressMapping_descriptor_, &AddressMapping::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AddressMappingSet_descriptor_, &AddressMappingSet::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DirService_descriptor_, &DirService::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ServiceDataMap_descriptor_, &ServiceDataMap::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Service_descriptor_, &Service::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ServiceSet_descriptor_, &ServiceSet::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Configuration_descriptor_, &Configuration::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + addressMappingGetRequest_descriptor_, &addressMappingGetRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + addressMappingGetResponse_descriptor_, &addressMappingGetResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + addressMappingSetResponse_descriptor_, &addressMappingSetResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + globalTimeSGetResponse_descriptor_, &globalTimeSGetResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + serviceDeregisterRequest_descriptor_, &serviceDeregisterRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + serviceGetByNameRequest_descriptor_, &serviceGetByNameRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + serviceGetByUUIDRequest_descriptor_, &serviceGetByUUIDRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + serviceGetByTypeRequest_descriptor_, &serviceGetByTypeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + serviceRegisterRequest_descriptor_, &serviceRegisterRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + serviceRegisterResponse_descriptor_, &serviceRegisterResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + configurationGetRequest_descriptor_, &configurationGetRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + configurationSetResponse_descriptor_, &configurationSetResponse::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto() { + delete AddressMapping::default_instance_; + delete AddressMapping_reflection_; + delete AddressMappingSet::default_instance_; + delete AddressMappingSet_reflection_; + delete DirService::default_instance_; + delete DirService_reflection_; + delete ServiceDataMap::default_instance_; + delete ServiceDataMap_reflection_; + delete Service::default_instance_; + delete Service_reflection_; + delete ServiceSet::default_instance_; + delete ServiceSet_reflection_; + delete Configuration::default_instance_; + delete Configuration_reflection_; + delete addressMappingGetRequest::default_instance_; + delete addressMappingGetRequest_reflection_; + delete addressMappingGetResponse::default_instance_; + delete addressMappingGetResponse_reflection_; + delete addressMappingSetResponse::default_instance_; + delete addressMappingSetResponse_reflection_; + delete globalTimeSGetResponse::default_instance_; + delete globalTimeSGetResponse_reflection_; + delete serviceDeregisterRequest::default_instance_; + delete serviceDeregisterRequest_reflection_; + delete serviceGetByNameRequest::default_instance_; + delete serviceGetByNameRequest_reflection_; + delete serviceGetByUUIDRequest::default_instance_; + delete serviceGetByUUIDRequest_reflection_; + delete serviceGetByTypeRequest::default_instance_; + delete serviceGetByTypeRequest_reflection_; + delete serviceRegisterRequest::default_instance_; + delete serviceRegisterRequest_reflection_; + delete serviceRegisterResponse::default_instance_; + delete serviceRegisterResponse_reflection_; + delete configurationGetRequest::default_instance_; + delete configurationGetRequest_reflection_; + delete configurationSetResponse::default_instance_; + delete configurationSetResponse_reflection_; +} + +void protobuf_AddDesc_xtreemfs_2fDIR_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fPBRPC_2eproto(); + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fCommon_2eproto(); + ::xtreemfs::pbrpc::protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\022xtreemfs/DIR.proto\022\016xtreemfs.pbrpc\032\023in" + "clude/PBRPC.proto\032\024include/Common.proto\032" + "\032xtreemfs/GlobalTypes.proto\"\223\001\n\016AddressM" + "apping\022\014\n\004uuid\030\001 \002(\t\022\017\n\007version\030\002 \002(\006\022\020\n" + "\010protocol\030\003 \002(\t\022\017\n\007address\030\004 \002(\t\022\014\n\004port" + "\030\005 \002(\007\022\025\n\rmatch_network\030\006 \002(\t\022\r\n\005ttl_s\030\007" + " \002(\007\022\013\n\003uri\030\010 \002(\t\"E\n\021AddressMappingSet\0220" + "\n\010mappings\030\001 \003(\0132\036.xtreemfs.pbrpc.Addres" + "sMapping\"X\n\nDirService\022\017\n\007address\030\001 \002(\t\022" + "\014\n\004port\030\002 \002(\007\022\020\n\010protocol\030\003 \002(\t\022\031\n\021inter" + "face_version\030\004 \002(\007\"<\n\016ServiceDataMap\022*\n\004" + "data\030\001 \003(\0132\034.xtreemfs.pbrpc.KeyValuePair" + "\"\247\001\n\007Service\022)\n\004type\030\001 \002(\0162\033.xtreemfs.pb" + "rpc.ServiceType\022\014\n\004uuid\030\002 \002(\t\022\017\n\007version" + "\030\003 \002(\006\022\014\n\004name\030\004 \002(\t\022\026\n\016last_updated_s\030\005" + " \002(\006\022,\n\004data\030\006 \002(\0132\036.xtreemfs.pbrpc.Serv" + "iceDataMap\"7\n\nServiceSet\022)\n\010services\030\001 \003" + "(\0132\027.xtreemfs.pbrpc.Service\"_\n\rConfigura" + "tion\022\014\n\004uuid\030\001 \002(\t\022/\n\tparameter\030\002 \003(\0132\034." + "xtreemfs.pbrpc.KeyValuePair\022\017\n\007version\030\003" + " \002(\006\"(\n\030addressMappingGetRequest\022\014\n\004uuid" + "\030\001 \002(\t\"N\n\031addressMappingGetResponse\0221\n\006r" + "esult\030\001 \001(\0132!.xtreemfs.pbrpc.AddressMapp" + "ingSet\"0\n\031addressMappingSetResponse\022\023\n\013n" + "ew_version\030\001 \001(\006\"1\n\026globalTimeSGetRespon" + "se\022\027\n\017time_in_seconds\030\001 \002(\006\"(\n\030serviceDe" + "registerRequest\022\014\n\004uuid\030\001 \002(\t\"\'\n\027service" + "GetByNameRequest\022\014\n\004name\030\001 \002(\t\"\'\n\027servic" + "eGetByUUIDRequest\022\014\n\004name\030\001 \002(\t\"D\n\027servi" + "ceGetByTypeRequest\022)\n\004type\030\001 \002(\0162\033.xtree" + "mfs.pbrpc.ServiceType\"B\n\026serviceRegister" + "Request\022(\n\007service\030\001 \002(\0132\027.xtreemfs.pbrp" + "c.Service\".\n\027serviceRegisterResponse\022\023\n\013" + "new_version\030\001 \002(\006\"\'\n\027configurationGetReq" + "uest\022\014\n\004uuid\030\001 \002(\t\"/\n\030configurationSetRe" + "sponse\022\023\n\013new_version\030\001 \001(\006*\200\001\n\013ServiceT" + "ype\022\026\n\022SERVICE_TYPE_MIXED\020\000\022\024\n\020SERVICE_T" + "YPE_MRC\020\001\022\024\n\020SERVICE_TYPE_OSD\020\002\022\027\n\023SERVI" + "CE_TYPE_VOLUME\020\003\022\024\n\020SERVICE_TYPE_DIR\020\004*g" + "\n\rServiceStatus\022\030\n\024SERVICE_STATUS_AVAIL\020" + "\000\022 \n\034SERVICE_STATUS_TO_BE_REMOVED\020\001\022\032\n\026S" + "ERVICE_STATUS_REMOVED\020\0022\355\r\n\020DirectorySer" + "vice\022u\n\035xtreemfs_address_mappings_get\022(." + "xtreemfs.pbrpc.addressMappingGetRequest\032" + "!.xtreemfs.pbrpc.AddressMappingSet\"\007\215\265\030\001" + "\000\000\000\022t\n xtreemfs_address_mappings_remove\022" + "(.xtreemfs.pbrpc.addressMappingGetReques" + "t\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265\030\002\000\000" + "\000\022v\n\035xtreemfs_address_mappings_set\022!.xtr" + "eemfs.pbrpc.AddressMappingSet\032).xtreemfs" + ".pbrpc.addressMappingSetResponse\"\007\215\265\030\003\000\000" + "\000\022Z\n\025xtreemfs_discover_dir\022\034.xtreemfs.pb" + "rpc.emptyRequest\032\032.xtreemfs.pbrpc.DirSer" + "vice\"\007\215\265\030\004\000\000\000\022k\n\032xtreemfs_global_time_s_" + "get\022\034.xtreemfs.pbrpc.emptyRequest\032&.xtre" + "emfs.pbrpc.globalTimeSGetResponse\"\007\215\265\030\005\000" + "\000\000\022o\n\033xtreemfs_service_deregister\022(.xtre" + "emfs.pbrpc.serviceDeregisterRequest\032\035.xt" + "reemfs.pbrpc.emptyResponse\"\007\215\265\030\006\000\000\000\022l\n\034x" + "treemfs_service_get_by_name\022\'.xtreemfs.p" + "brpc.serviceGetByNameRequest\032\032.xtreemfs." + "pbrpc.ServiceSet\"\007\215\265\030\007\000\000\000\022l\n\034xtreemfs_se" + "rvice_get_by_type\022\'.xtreemfs.pbrpc.servi" + "ceGetByTypeRequest\032\032.xtreemfs.pbrpc.Serv" + "iceSet\"\007\215\265\030\010\000\000\000\022l\n\034xtreemfs_service_get_" + "by_uuid\022\'.xtreemfs.pbrpc.serviceGetByUUI" + "DRequest\032\032.xtreemfs.pbrpc.ServiceSet\"\007\215\265" + "\030\t\000\000\000\022k\n\030xtreemfs_service_offline\022\'.xtre" + "emfs.pbrpc.serviceGetByUUIDRequest\032\035.xtr" + "eemfs.pbrpc.emptyResponse\"\007\215\265\030\n\000\000\000\022u\n\031xt" + "reemfs_service_register\022&.xtreemfs.pbrpc" + ".serviceRegisterRequest\032\'.xtreemfs.pbrpc" + ".serviceRegisterResponse\"\007\215\265\030\013\000\000\000\022[\n\023xtr" + "eemfs_checkpoint\022\034.xtreemfs.pbrpc.emptyR" + "equest\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215" + "\265\030\024\000\000\000\022Y\n\021xtreemfs_shutdown\022\034.xtreemfs.p" + "brpc.emptyRequest\032\035.xtreemfs.pbrpc.empty" + "Response\"\007\215\265\030\025\000\000\000\022m\n\032xtreemfs_configurat" + "ion_get\022\'.xtreemfs.pbrpc.configurationGe" + "tRequest\032\035.xtreemfs.pbrpc.Configuration\"" + "\007\215\265\030\026\000\000\000\022n\n\032xtreemfs_configuration_set\022\035" + ".xtreemfs.pbrpc.Configuration\032(.xtreemfs" + ".pbrpc.configurationSetResponse\"\007\215\265\030\027\000\000\000" + "\022l\n\036xtreemfs_vivaldi_client_update\022\".xtr" + "eemfs.pbrpc.VivaldiCoordinates\032\035.xtreemf" + "s.pbrpc.emptyResponse\"\007\215\265\030\030\000\000\000\032\007\225\265\030\021\'\000\000B" + "(\n&org.xtreemfs.pbrpc.generatedinterface" + "s", 3481); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "xtreemfs/DIR.proto", &protobuf_RegisterTypes); + AddressMapping::default_instance_ = new AddressMapping(); + AddressMappingSet::default_instance_ = new AddressMappingSet(); + DirService::default_instance_ = new DirService(); + ServiceDataMap::default_instance_ = new ServiceDataMap(); + Service::default_instance_ = new Service(); + ServiceSet::default_instance_ = new ServiceSet(); + Configuration::default_instance_ = new Configuration(); + addressMappingGetRequest::default_instance_ = new addressMappingGetRequest(); + addressMappingGetResponse::default_instance_ = new addressMappingGetResponse(); + addressMappingSetResponse::default_instance_ = new addressMappingSetResponse(); + globalTimeSGetResponse::default_instance_ = new globalTimeSGetResponse(); + serviceDeregisterRequest::default_instance_ = new serviceDeregisterRequest(); + serviceGetByNameRequest::default_instance_ = new serviceGetByNameRequest(); + serviceGetByUUIDRequest::default_instance_ = new serviceGetByUUIDRequest(); + serviceGetByTypeRequest::default_instance_ = new serviceGetByTypeRequest(); + serviceRegisterRequest::default_instance_ = new serviceRegisterRequest(); + serviceRegisterResponse::default_instance_ = new serviceRegisterResponse(); + configurationGetRequest::default_instance_ = new configurationGetRequest(); + configurationSetResponse::default_instance_ = new configurationSetResponse(); + AddressMapping::default_instance_->InitAsDefaultInstance(); + AddressMappingSet::default_instance_->InitAsDefaultInstance(); + DirService::default_instance_->InitAsDefaultInstance(); + ServiceDataMap::default_instance_->InitAsDefaultInstance(); + Service::default_instance_->InitAsDefaultInstance(); + ServiceSet::default_instance_->InitAsDefaultInstance(); + Configuration::default_instance_->InitAsDefaultInstance(); + addressMappingGetRequest::default_instance_->InitAsDefaultInstance(); + addressMappingGetResponse::default_instance_->InitAsDefaultInstance(); + addressMappingSetResponse::default_instance_->InitAsDefaultInstance(); + globalTimeSGetResponse::default_instance_->InitAsDefaultInstance(); + serviceDeregisterRequest::default_instance_->InitAsDefaultInstance(); + serviceGetByNameRequest::default_instance_->InitAsDefaultInstance(); + serviceGetByUUIDRequest::default_instance_->InitAsDefaultInstance(); + serviceGetByTypeRequest::default_instance_->InitAsDefaultInstance(); + serviceRegisterRequest::default_instance_->InitAsDefaultInstance(); + serviceRegisterResponse::default_instance_->InitAsDefaultInstance(); + configurationGetRequest::default_instance_->InitAsDefaultInstance(); + configurationSetResponse::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_xtreemfs_2fDIR_2eproto { + StaticDescriptorInitializer_xtreemfs_2fDIR_2eproto() { + protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + } +} static_descriptor_initializer_xtreemfs_2fDIR_2eproto_; +const ::google::protobuf::EnumDescriptor* ServiceType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServiceType_descriptor_; +} +bool ServiceType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServiceStatus_descriptor_; +} +bool ServiceStatus_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AddressMapping::kUuidFieldNumber; +const int AddressMapping::kVersionFieldNumber; +const int AddressMapping::kProtocolFieldNumber; +const int AddressMapping::kAddressFieldNumber; +const int AddressMapping::kPortFieldNumber; +const int AddressMapping::kMatchNetworkFieldNumber; +const int AddressMapping::kTtlSFieldNumber; +const int AddressMapping::kUriFieldNumber; +#endif // !_MSC_VER + +AddressMapping::AddressMapping() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void AddressMapping::InitAsDefaultInstance() { +} + +AddressMapping::AddressMapping(const AddressMapping& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void AddressMapping::SharedCtor() { + _cached_size_ = 0; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + version_ = GOOGLE_ULONGLONG(0); + protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + port_ = 0u; + match_network_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ttl_s_ = 0u; + uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AddressMapping::~AddressMapping() { + SharedDtor(); +} + +void AddressMapping::SharedDtor() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (protocol_ != &::google::protobuf::internal::kEmptyString) { + delete protocol_; + } + if (address_ != &::google::protobuf::internal::kEmptyString) { + delete address_; + } + if (match_network_ != &::google::protobuf::internal::kEmptyString) { + delete match_network_; + } + if (uri_ != &::google::protobuf::internal::kEmptyString) { + delete uri_; + } + if (this != default_instance_) { + } +} + +void AddressMapping::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AddressMapping::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AddressMapping_descriptor_; +} + +const AddressMapping& AddressMapping::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +AddressMapping* AddressMapping::default_instance_ = NULL; + +AddressMapping* AddressMapping::New() const { + return new AddressMapping; +} + +void AddressMapping::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_uuid()) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + } + version_ = GOOGLE_ULONGLONG(0); + if (has_protocol()) { + if (protocol_ != &::google::protobuf::internal::kEmptyString) { + protocol_->clear(); + } + } + if (has_address()) { + if (address_ != &::google::protobuf::internal::kEmptyString) { + address_->clear(); + } + } + port_ = 0u; + if (has_match_network()) { + if (match_network_ != &::google::protobuf::internal::kEmptyString) { + match_network_->clear(); + } + } + ttl_s_ = 0u; + if (has_uri()) { + if (uri_ != &::google::protobuf::internal::kEmptyString) { + uri_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AddressMapping::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string uuid = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_version; + break; + } + + // required fixed64 version = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &version_))); + set_has_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_protocol; + break; + } + + // required string protocol = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_protocol: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_protocol())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->protocol().data(), this->protocol().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_address; + break; + } + + // required string address = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_address: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_address())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_port; + break; + } + + // required fixed32 port = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_port: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &port_))); + set_has_port(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_match_network; + break; + } + + // required string match_network = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_match_network: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_match_network())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->match_network().data(), this->match_network().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(61)) goto parse_ttl_s; + break; + } + + // required fixed32 ttl_s = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_ttl_s: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &ttl_s_))); + set_has_ttl_s(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_uri; + break; + } + + // required string uri = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_uri: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_uri())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uri().data(), this->uri().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void AddressMapping::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->uuid(), output); + } + + // required fixed64 version = 2; + if (has_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->version(), output); + } + + // required string protocol = 3; + if (has_protocol()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->protocol().data(), this->protocol().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->protocol(), output); + } + + // required string address = 4; + if (has_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->address(), output); + } + + // required fixed32 port = 5; + if (has_port()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->port(), output); + } + + // required string match_network = 6; + if (has_match_network()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->match_network().data(), this->match_network().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 6, this->match_network(), output); + } + + // required fixed32 ttl_s = 7; + if (has_ttl_s()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(7, this->ttl_s(), output); + } + + // required string uri = 8; + if (has_uri()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uri().data(), this->uri().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 8, this->uri(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* AddressMapping::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->uuid(), target); + } + + // required fixed64 version = 2; + if (has_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->version(), target); + } + + // required string protocol = 3; + if (has_protocol()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->protocol().data(), this->protocol().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->protocol(), target); + } + + // required string address = 4; + if (has_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->address(), target); + } + + // required fixed32 port = 5; + if (has_port()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->port(), target); + } + + // required string match_network = 6; + if (has_match_network()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->match_network().data(), this->match_network().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->match_network(), target); + } + + // required fixed32 ttl_s = 7; + if (has_ttl_s()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(7, this->ttl_s(), target); + } + + // required string uri = 8; + if (has_uri()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uri().data(), this->uri().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 8, this->uri(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int AddressMapping::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string uuid = 1; + if (has_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->uuid()); + } + + // required fixed64 version = 2; + if (has_version()) { + total_size += 1 + 8; + } + + // required string protocol = 3; + if (has_protocol()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->protocol()); + } + + // required string address = 4; + if (has_address()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->address()); + } + + // required fixed32 port = 5; + if (has_port()) { + total_size += 1 + 4; + } + + // required string match_network = 6; + if (has_match_network()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->match_network()); + } + + // required fixed32 ttl_s = 7; + if (has_ttl_s()) { + total_size += 1 + 4; + } + + // required string uri = 8; + if (has_uri()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->uri()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AddressMapping::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AddressMapping* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AddressMapping::MergeFrom(const AddressMapping& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_uuid()) { + set_uuid(from.uuid()); + } + if (from.has_version()) { + set_version(from.version()); + } + if (from.has_protocol()) { + set_protocol(from.protocol()); + } + if (from.has_address()) { + set_address(from.address()); + } + if (from.has_port()) { + set_port(from.port()); + } + if (from.has_match_network()) { + set_match_network(from.match_network()); + } + if (from.has_ttl_s()) { + set_ttl_s(from.ttl_s()); + } + if (from.has_uri()) { + set_uri(from.uri()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AddressMapping::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AddressMapping::CopyFrom(const AddressMapping& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AddressMapping::IsInitialized() const { + if ((_has_bits_[0] & 0x000000ff) != 0x000000ff) return false; + + return true; +} + +void AddressMapping::Swap(AddressMapping* other) { + if (other != this) { + std::swap(uuid_, other->uuid_); + std::swap(version_, other->version_); + std::swap(protocol_, other->protocol_); + std::swap(address_, other->address_); + std::swap(port_, other->port_); + std::swap(match_network_, other->match_network_); + std::swap(ttl_s_, other->ttl_s_); + std::swap(uri_, other->uri_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata AddressMapping::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AddressMapping_descriptor_; + metadata.reflection = AddressMapping_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AddressMappingSet::kMappingsFieldNumber; +#endif // !_MSC_VER + +AddressMappingSet::AddressMappingSet() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void AddressMappingSet::InitAsDefaultInstance() { +} + +AddressMappingSet::AddressMappingSet(const AddressMappingSet& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void AddressMappingSet::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AddressMappingSet::~AddressMappingSet() { + SharedDtor(); +} + +void AddressMappingSet::SharedDtor() { + if (this != default_instance_) { + } +} + +void AddressMappingSet::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AddressMappingSet::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AddressMappingSet_descriptor_; +} + +const AddressMappingSet& AddressMappingSet::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +AddressMappingSet* AddressMappingSet::default_instance_ = NULL; + +AddressMappingSet* AddressMappingSet::New() const { + return new AddressMappingSet; +} + +void AddressMappingSet::Clear() { + mappings_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AddressMappingSet::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_mappings: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_mappings())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_mappings; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void AddressMappingSet::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1; + for (int i = 0; i < this->mappings_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->mappings(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* AddressMappingSet::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1; + for (int i = 0; i < this->mappings_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->mappings(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int AddressMappingSet::ByteSize() const { + int total_size = 0; + + // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1; + total_size += 1 * this->mappings_size(); + for (int i = 0; i < this->mappings_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->mappings(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AddressMappingSet::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AddressMappingSet* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AddressMappingSet::MergeFrom(const AddressMappingSet& from) { + GOOGLE_CHECK_NE(&from, this); + mappings_.MergeFrom(from.mappings_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AddressMappingSet::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AddressMappingSet::CopyFrom(const AddressMappingSet& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AddressMappingSet::IsInitialized() const { + + for (int i = 0; i < mappings_size(); i++) { + if (!this->mappings(i).IsInitialized()) return false; + } + return true; +} + +void AddressMappingSet::Swap(AddressMappingSet* other) { + if (other != this) { + mappings_.Swap(&other->mappings_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata AddressMappingSet::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AddressMappingSet_descriptor_; + metadata.reflection = AddressMappingSet_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DirService::kAddressFieldNumber; +const int DirService::kPortFieldNumber; +const int DirService::kProtocolFieldNumber; +const int DirService::kInterfaceVersionFieldNumber; +#endif // !_MSC_VER + +DirService::DirService() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void DirService::InitAsDefaultInstance() { +} + +DirService::DirService(const DirService& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void DirService::SharedCtor() { + _cached_size_ = 0; + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + port_ = 0u; + protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + interface_version_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DirService::~DirService() { + SharedDtor(); +} + +void DirService::SharedDtor() { + if (address_ != &::google::protobuf::internal::kEmptyString) { + delete address_; + } + if (protocol_ != &::google::protobuf::internal::kEmptyString) { + delete protocol_; + } + if (this != default_instance_) { + } +} + +void DirService::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DirService::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DirService_descriptor_; +} + +const DirService& DirService::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +DirService* DirService::default_instance_ = NULL; + +DirService* DirService::New() const { + return new DirService; +} + +void DirService::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_address()) { + if (address_ != &::google::protobuf::internal::kEmptyString) { + address_->clear(); + } + } + port_ = 0u; + if (has_protocol()) { + if (protocol_ != &::google::protobuf::internal::kEmptyString) { + protocol_->clear(); + } + } + interface_version_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool DirService::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string address = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_address())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_port; + break; + } + + // required fixed32 port = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_port: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &port_))); + set_has_port(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_protocol; + break; + } + + // required string protocol = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_protocol: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_protocol())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->protocol().data(), this->protocol().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_interface_version; + break; + } + + // required fixed32 interface_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_interface_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &interface_version_))); + set_has_interface_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void DirService::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string address = 1; + if (has_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->address(), output); + } + + // required fixed32 port = 2; + if (has_port()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->port(), output); + } + + // required string protocol = 3; + if (has_protocol()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->protocol().data(), this->protocol().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->protocol(), output); + } + + // required fixed32 interface_version = 4; + if (has_interface_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->interface_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* DirService::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string address = 1; + if (has_address()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->address().data(), this->address().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->address(), target); + } + + // required fixed32 port = 2; + if (has_port()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->port(), target); + } + + // required string protocol = 3; + if (has_protocol()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->protocol().data(), this->protocol().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->protocol(), target); + } + + // required fixed32 interface_version = 4; + if (has_interface_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->interface_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int DirService::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string address = 1; + if (has_address()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->address()); + } + + // required fixed32 port = 2; + if (has_port()) { + total_size += 1 + 4; + } + + // required string protocol = 3; + if (has_protocol()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->protocol()); + } + + // required fixed32 interface_version = 4; + if (has_interface_version()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DirService::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const DirService* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void DirService::MergeFrom(const DirService& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_address()) { + set_address(from.address()); + } + if (from.has_port()) { + set_port(from.port()); + } + if (from.has_protocol()) { + set_protocol(from.protocol()); + } + if (from.has_interface_version()) { + set_interface_version(from.interface_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void DirService::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DirService::CopyFrom(const DirService& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DirService::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + return true; +} + +void DirService::Swap(DirService* other) { + if (other != this) { + std::swap(address_, other->address_); + std::swap(port_, other->port_); + std::swap(protocol_, other->protocol_); + std::swap(interface_version_, other->interface_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata DirService::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DirService_descriptor_; + metadata.reflection = DirService_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ServiceDataMap::kDataFieldNumber; +#endif // !_MSC_VER + +ServiceDataMap::ServiceDataMap() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ServiceDataMap::InitAsDefaultInstance() { +} + +ServiceDataMap::ServiceDataMap(const ServiceDataMap& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ServiceDataMap::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ServiceDataMap::~ServiceDataMap() { + SharedDtor(); +} + +void ServiceDataMap::SharedDtor() { + if (this != default_instance_) { + } +} + +void ServiceDataMap::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ServiceDataMap::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServiceDataMap_descriptor_; +} + +const ServiceDataMap& ServiceDataMap::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +ServiceDataMap* ServiceDataMap::default_instance_ = NULL; + +ServiceDataMap* ServiceDataMap::New() const { + return new ServiceDataMap; +} + +void ServiceDataMap::Clear() { + data_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ServiceDataMap::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .xtreemfs.pbrpc.KeyValuePair data = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_data())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_data; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ServiceDataMap::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .xtreemfs.pbrpc.KeyValuePair data = 1; + for (int i = 0; i < this->data_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->data(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ServiceDataMap::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .xtreemfs.pbrpc.KeyValuePair data = 1; + for (int i = 0; i < this->data_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->data(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ServiceDataMap::ByteSize() const { + int total_size = 0; + + // repeated .xtreemfs.pbrpc.KeyValuePair data = 1; + total_size += 1 * this->data_size(); + for (int i = 0; i < this->data_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->data(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ServiceDataMap::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ServiceDataMap* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ServiceDataMap::MergeFrom(const ServiceDataMap& from) { + GOOGLE_CHECK_NE(&from, this); + data_.MergeFrom(from.data_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ServiceDataMap::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServiceDataMap::CopyFrom(const ServiceDataMap& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServiceDataMap::IsInitialized() const { + + for (int i = 0; i < data_size(); i++) { + if (!this->data(i).IsInitialized()) return false; + } + return true; +} + +void ServiceDataMap::Swap(ServiceDataMap* other) { + if (other != this) { + data_.Swap(&other->data_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ServiceDataMap::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ServiceDataMap_descriptor_; + metadata.reflection = ServiceDataMap_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Service::kTypeFieldNumber; +const int Service::kUuidFieldNumber; +const int Service::kVersionFieldNumber; +const int Service::kNameFieldNumber; +const int Service::kLastUpdatedSFieldNumber; +const int Service::kDataFieldNumber; +#endif // !_MSC_VER + +Service::Service() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Service::InitAsDefaultInstance() { + data_ = const_cast< ::xtreemfs::pbrpc::ServiceDataMap*>(&::xtreemfs::pbrpc::ServiceDataMap::default_instance()); +} + +Service::Service(const Service& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Service::SharedCtor() { + _cached_size_ = 0; + type_ = 0; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + version_ = GOOGLE_ULONGLONG(0); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + last_updated_s_ = GOOGLE_ULONGLONG(0); + data_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Service::~Service() { + SharedDtor(); +} + +void Service::SharedDtor() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + delete data_; + } +} + +void Service::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Service::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Service_descriptor_; +} + +const Service& Service::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +Service* Service::default_instance_ = NULL; + +Service* Service::New() const { + return new Service; +} + +void Service::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + type_ = 0; + if (has_uuid()) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + } + version_ = GOOGLE_ULONGLONG(0); + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + last_updated_s_ = GOOGLE_ULONGLONG(0); + if (has_data()) { + if (data_ != NULL) data_->::xtreemfs::pbrpc::ServiceDataMap::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Service::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.ServiceType type = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::ServiceType_IsValid(value)) { + set_type(static_cast< ::xtreemfs::pbrpc::ServiceType >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_uuid; + break; + } + + // required string uuid = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_uuid: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_version; + break; + } + + // required fixed64 version = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &version_))); + set_has_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_name; + break; + } + + // required string name = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(41)) goto parse_last_updated_s; + break; + } + + // required fixed64 last_updated_s = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_last_updated_s: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &last_updated_s_))); + set_has_last_updated_s(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_data; + break; + } + + // required .xtreemfs.pbrpc.ServiceDataMap data = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_data())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Service::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.ServiceType type = 1; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->type(), output); + } + + // required string uuid = 2; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->uuid(), output); + } + + // required fixed64 version = 3; + if (has_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output); + } + + // required string name = 4; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->name(), output); + } + + // required fixed64 last_updated_s = 5; + if (has_last_updated_s()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(5, this->last_updated_s(), output); + } + + // required .xtreemfs.pbrpc.ServiceDataMap data = 6; + if (has_data()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->data(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Service::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.ServiceType type = 1; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->type(), target); + } + + // required string uuid = 2; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->uuid(), target); + } + + // required fixed64 version = 3; + if (has_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target); + } + + // required string name = 4; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->name(), target); + } + + // required fixed64 last_updated_s = 5; + if (has_last_updated_s()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(5, this->last_updated_s(), target); + } + + // required .xtreemfs.pbrpc.ServiceDataMap data = 6; + if (has_data()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->data(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Service::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.ServiceType type = 1; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + // required string uuid = 2; + if (has_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->uuid()); + } + + // required fixed64 version = 3; + if (has_version()) { + total_size += 1 + 8; + } + + // required string name = 4; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // required fixed64 last_updated_s = 5; + if (has_last_updated_s()) { + total_size += 1 + 8; + } + + // required .xtreemfs.pbrpc.ServiceDataMap data = 6; + if (has_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->data()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Service::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Service* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Service::MergeFrom(const Service& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_type()) { + set_type(from.type()); + } + if (from.has_uuid()) { + set_uuid(from.uuid()); + } + if (from.has_version()) { + set_version(from.version()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_last_updated_s()) { + set_last_updated_s(from.last_updated_s()); + } + if (from.has_data()) { + mutable_data()->::xtreemfs::pbrpc::ServiceDataMap::MergeFrom(from.data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Service::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Service::CopyFrom(const Service& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Service::IsInitialized() const { + if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false; + + if (has_data()) { + if (!this->data().IsInitialized()) return false; + } + return true; +} + +void Service::Swap(Service* other) { + if (other != this) { + std::swap(type_, other->type_); + std::swap(uuid_, other->uuid_); + std::swap(version_, other->version_); + std::swap(name_, other->name_); + std::swap(last_updated_s_, other->last_updated_s_); + std::swap(data_, other->data_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Service::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Service_descriptor_; + metadata.reflection = Service_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ServiceSet::kServicesFieldNumber; +#endif // !_MSC_VER + +ServiceSet::ServiceSet() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ServiceSet::InitAsDefaultInstance() { +} + +ServiceSet::ServiceSet(const ServiceSet& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ServiceSet::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ServiceSet::~ServiceSet() { + SharedDtor(); +} + +void ServiceSet::SharedDtor() { + if (this != default_instance_) { + } +} + +void ServiceSet::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ServiceSet::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServiceSet_descriptor_; +} + +const ServiceSet& ServiceSet::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +ServiceSet* ServiceSet::default_instance_ = NULL; + +ServiceSet* ServiceSet::New() const { + return new ServiceSet; +} + +void ServiceSet::Clear() { + services_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ServiceSet::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .xtreemfs.pbrpc.Service services = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_services: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_services())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_services; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ServiceSet::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .xtreemfs.pbrpc.Service services = 1; + for (int i = 0; i < this->services_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->services(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ServiceSet::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .xtreemfs.pbrpc.Service services = 1; + for (int i = 0; i < this->services_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->services(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ServiceSet::ByteSize() const { + int total_size = 0; + + // repeated .xtreemfs.pbrpc.Service services = 1; + total_size += 1 * this->services_size(); + for (int i = 0; i < this->services_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->services(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ServiceSet::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ServiceSet* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ServiceSet::MergeFrom(const ServiceSet& from) { + GOOGLE_CHECK_NE(&from, this); + services_.MergeFrom(from.services_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ServiceSet::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServiceSet::CopyFrom(const ServiceSet& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServiceSet::IsInitialized() const { + + for (int i = 0; i < services_size(); i++) { + if (!this->services(i).IsInitialized()) return false; + } + return true; +} + +void ServiceSet::Swap(ServiceSet* other) { + if (other != this) { + services_.Swap(&other->services_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ServiceSet::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ServiceSet_descriptor_; + metadata.reflection = ServiceSet_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Configuration::kUuidFieldNumber; +const int Configuration::kParameterFieldNumber; +const int Configuration::kVersionFieldNumber; +#endif // !_MSC_VER + +Configuration::Configuration() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Configuration::InitAsDefaultInstance() { +} + +Configuration::Configuration(const Configuration& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Configuration::SharedCtor() { + _cached_size_ = 0; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Configuration::~Configuration() { + SharedDtor(); +} + +void Configuration::SharedDtor() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (this != default_instance_) { + } +} + +void Configuration::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Configuration::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Configuration_descriptor_; +} + +const Configuration& Configuration::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +Configuration* Configuration::default_instance_ = NULL; + +Configuration* Configuration::New() const { + return new Configuration; +} + +void Configuration::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_uuid()) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + } + version_ = GOOGLE_ULONGLONG(0); + } + parameter_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Configuration::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string uuid = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_parameter; + break; + } + + // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_parameter: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_parameter())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_parameter; + if (input->ExpectTag(25)) goto parse_version; + break; + } + + // required fixed64 version = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &version_))); + set_has_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Configuration::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->uuid(), output); + } + + // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2; + for (int i = 0; i < this->parameter_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->parameter(i), output); + } + + // required fixed64 version = 3; + if (has_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Configuration::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->uuid(), target); + } + + // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2; + for (int i = 0; i < this->parameter_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->parameter(i), target); + } + + // required fixed64 version = 3; + if (has_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Configuration::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string uuid = 1; + if (has_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->uuid()); + } + + // required fixed64 version = 3; + if (has_version()) { + total_size += 1 + 8; + } + + } + // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2; + total_size += 1 * this->parameter_size(); + for (int i = 0; i < this->parameter_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->parameter(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Configuration::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Configuration* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Configuration::MergeFrom(const Configuration& from) { + GOOGLE_CHECK_NE(&from, this); + parameter_.MergeFrom(from.parameter_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_uuid()) { + set_uuid(from.uuid()); + } + if (from.has_version()) { + set_version(from.version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Configuration::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Configuration::CopyFrom(const Configuration& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Configuration::IsInitialized() const { + if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; + + for (int i = 0; i < parameter_size(); i++) { + if (!this->parameter(i).IsInitialized()) return false; + } + return true; +} + +void Configuration::Swap(Configuration* other) { + if (other != this) { + std::swap(uuid_, other->uuid_); + parameter_.Swap(&other->parameter_); + std::swap(version_, other->version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Configuration::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Configuration_descriptor_; + metadata.reflection = Configuration_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int addressMappingGetRequest::kUuidFieldNumber; +#endif // !_MSC_VER + +addressMappingGetRequest::addressMappingGetRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void addressMappingGetRequest::InitAsDefaultInstance() { +} + +addressMappingGetRequest::addressMappingGetRequest(const addressMappingGetRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void addressMappingGetRequest::SharedCtor() { + _cached_size_ = 0; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +addressMappingGetRequest::~addressMappingGetRequest() { + SharedDtor(); +} + +void addressMappingGetRequest::SharedDtor() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (this != default_instance_) { + } +} + +void addressMappingGetRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* addressMappingGetRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return addressMappingGetRequest_descriptor_; +} + +const addressMappingGetRequest& addressMappingGetRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +addressMappingGetRequest* addressMappingGetRequest::default_instance_ = NULL; + +addressMappingGetRequest* addressMappingGetRequest::New() const { + return new addressMappingGetRequest; +} + +void addressMappingGetRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_uuid()) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool addressMappingGetRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string uuid = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void addressMappingGetRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->uuid(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* addressMappingGetRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->uuid(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int addressMappingGetRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string uuid = 1; + if (has_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->uuid()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void addressMappingGetRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const addressMappingGetRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void addressMappingGetRequest::MergeFrom(const addressMappingGetRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_uuid()) { + set_uuid(from.uuid()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void addressMappingGetRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void addressMappingGetRequest::CopyFrom(const addressMappingGetRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool addressMappingGetRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void addressMappingGetRequest::Swap(addressMappingGetRequest* other) { + if (other != this) { + std::swap(uuid_, other->uuid_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata addressMappingGetRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = addressMappingGetRequest_descriptor_; + metadata.reflection = addressMappingGetRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int addressMappingGetResponse::kResultFieldNumber; +#endif // !_MSC_VER + +addressMappingGetResponse::addressMappingGetResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void addressMappingGetResponse::InitAsDefaultInstance() { + result_ = const_cast< ::xtreemfs::pbrpc::AddressMappingSet*>(&::xtreemfs::pbrpc::AddressMappingSet::default_instance()); +} + +addressMappingGetResponse::addressMappingGetResponse(const addressMappingGetResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void addressMappingGetResponse::SharedCtor() { + _cached_size_ = 0; + result_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +addressMappingGetResponse::~addressMappingGetResponse() { + SharedDtor(); +} + +void addressMappingGetResponse::SharedDtor() { + if (this != default_instance_) { + delete result_; + } +} + +void addressMappingGetResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* addressMappingGetResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return addressMappingGetResponse_descriptor_; +} + +const addressMappingGetResponse& addressMappingGetResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +addressMappingGetResponse* addressMappingGetResponse::default_instance_ = NULL; + +addressMappingGetResponse* addressMappingGetResponse::New() const { + return new addressMappingGetResponse; +} + +void addressMappingGetResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_result()) { + if (result_ != NULL) result_->::xtreemfs::pbrpc::AddressMappingSet::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool addressMappingGetResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .xtreemfs.pbrpc.AddressMappingSet result = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_result())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void addressMappingGetResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .xtreemfs.pbrpc.AddressMappingSet result = 1; + if (has_result()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->result(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* addressMappingGetResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .xtreemfs.pbrpc.AddressMappingSet result = 1; + if (has_result()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->result(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int addressMappingGetResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .xtreemfs.pbrpc.AddressMappingSet result = 1; + if (has_result()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->result()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void addressMappingGetResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const addressMappingGetResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void addressMappingGetResponse::MergeFrom(const addressMappingGetResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_result()) { + mutable_result()->::xtreemfs::pbrpc::AddressMappingSet::MergeFrom(from.result()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void addressMappingGetResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void addressMappingGetResponse::CopyFrom(const addressMappingGetResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool addressMappingGetResponse::IsInitialized() const { + + if (has_result()) { + if (!this->result().IsInitialized()) return false; + } + return true; +} + +void addressMappingGetResponse::Swap(addressMappingGetResponse* other) { + if (other != this) { + std::swap(result_, other->result_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata addressMappingGetResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = addressMappingGetResponse_descriptor_; + metadata.reflection = addressMappingGetResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int addressMappingSetResponse::kNewVersionFieldNumber; +#endif // !_MSC_VER + +addressMappingSetResponse::addressMappingSetResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void addressMappingSetResponse::InitAsDefaultInstance() { +} + +addressMappingSetResponse::addressMappingSetResponse(const addressMappingSetResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void addressMappingSetResponse::SharedCtor() { + _cached_size_ = 0; + new_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +addressMappingSetResponse::~addressMappingSetResponse() { + SharedDtor(); +} + +void addressMappingSetResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void addressMappingSetResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* addressMappingSetResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return addressMappingSetResponse_descriptor_; +} + +const addressMappingSetResponse& addressMappingSetResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +addressMappingSetResponse* addressMappingSetResponse::default_instance_ = NULL; + +addressMappingSetResponse* addressMappingSetResponse::New() const { + return new addressMappingSetResponse; +} + +void addressMappingSetResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + new_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool addressMappingSetResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional fixed64 new_version = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &new_version_))); + set_has_new_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void addressMappingSetResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional fixed64 new_version = 1; + if (has_new_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* addressMappingSetResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional fixed64 new_version = 1; + if (has_new_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int addressMappingSetResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed64 new_version = 1; + if (has_new_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void addressMappingSetResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const addressMappingSetResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void addressMappingSetResponse::MergeFrom(const addressMappingSetResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_new_version()) { + set_new_version(from.new_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void addressMappingSetResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void addressMappingSetResponse::CopyFrom(const addressMappingSetResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool addressMappingSetResponse::IsInitialized() const { + + return true; +} + +void addressMappingSetResponse::Swap(addressMappingSetResponse* other) { + if (other != this) { + std::swap(new_version_, other->new_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata addressMappingSetResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = addressMappingSetResponse_descriptor_; + metadata.reflection = addressMappingSetResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int globalTimeSGetResponse::kTimeInSecondsFieldNumber; +#endif // !_MSC_VER + +globalTimeSGetResponse::globalTimeSGetResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void globalTimeSGetResponse::InitAsDefaultInstance() { +} + +globalTimeSGetResponse::globalTimeSGetResponse(const globalTimeSGetResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void globalTimeSGetResponse::SharedCtor() { + _cached_size_ = 0; + time_in_seconds_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +globalTimeSGetResponse::~globalTimeSGetResponse() { + SharedDtor(); +} + +void globalTimeSGetResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void globalTimeSGetResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* globalTimeSGetResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return globalTimeSGetResponse_descriptor_; +} + +const globalTimeSGetResponse& globalTimeSGetResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +globalTimeSGetResponse* globalTimeSGetResponse::default_instance_ = NULL; + +globalTimeSGetResponse* globalTimeSGetResponse::New() const { + return new globalTimeSGetResponse; +} + +void globalTimeSGetResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + time_in_seconds_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool globalTimeSGetResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 time_in_seconds = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &time_in_seconds_))); + set_has_time_in_seconds(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void globalTimeSGetResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 time_in_seconds = 1; + if (has_time_in_seconds()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->time_in_seconds(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* globalTimeSGetResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 time_in_seconds = 1; + if (has_time_in_seconds()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->time_in_seconds(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int globalTimeSGetResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 time_in_seconds = 1; + if (has_time_in_seconds()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void globalTimeSGetResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const globalTimeSGetResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void globalTimeSGetResponse::MergeFrom(const globalTimeSGetResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_time_in_seconds()) { + set_time_in_seconds(from.time_in_seconds()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void globalTimeSGetResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void globalTimeSGetResponse::CopyFrom(const globalTimeSGetResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool globalTimeSGetResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void globalTimeSGetResponse::Swap(globalTimeSGetResponse* other) { + if (other != this) { + std::swap(time_in_seconds_, other->time_in_seconds_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata globalTimeSGetResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = globalTimeSGetResponse_descriptor_; + metadata.reflection = globalTimeSGetResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int serviceDeregisterRequest::kUuidFieldNumber; +#endif // !_MSC_VER + +serviceDeregisterRequest::serviceDeregisterRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void serviceDeregisterRequest::InitAsDefaultInstance() { +} + +serviceDeregisterRequest::serviceDeregisterRequest(const serviceDeregisterRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void serviceDeregisterRequest::SharedCtor() { + _cached_size_ = 0; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +serviceDeregisterRequest::~serviceDeregisterRequest() { + SharedDtor(); +} + +void serviceDeregisterRequest::SharedDtor() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (this != default_instance_) { + } +} + +void serviceDeregisterRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* serviceDeregisterRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return serviceDeregisterRequest_descriptor_; +} + +const serviceDeregisterRequest& serviceDeregisterRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +serviceDeregisterRequest* serviceDeregisterRequest::default_instance_ = NULL; + +serviceDeregisterRequest* serviceDeregisterRequest::New() const { + return new serviceDeregisterRequest; +} + +void serviceDeregisterRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_uuid()) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool serviceDeregisterRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string uuid = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void serviceDeregisterRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->uuid(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* serviceDeregisterRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->uuid(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int serviceDeregisterRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string uuid = 1; + if (has_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->uuid()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void serviceDeregisterRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const serviceDeregisterRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void serviceDeregisterRequest::MergeFrom(const serviceDeregisterRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_uuid()) { + set_uuid(from.uuid()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void serviceDeregisterRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void serviceDeregisterRequest::CopyFrom(const serviceDeregisterRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool serviceDeregisterRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void serviceDeregisterRequest::Swap(serviceDeregisterRequest* other) { + if (other != this) { + std::swap(uuid_, other->uuid_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata serviceDeregisterRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = serviceDeregisterRequest_descriptor_; + metadata.reflection = serviceDeregisterRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int serviceGetByNameRequest::kNameFieldNumber; +#endif // !_MSC_VER + +serviceGetByNameRequest::serviceGetByNameRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void serviceGetByNameRequest::InitAsDefaultInstance() { +} + +serviceGetByNameRequest::serviceGetByNameRequest(const serviceGetByNameRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void serviceGetByNameRequest::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +serviceGetByNameRequest::~serviceGetByNameRequest() { + SharedDtor(); +} + +void serviceGetByNameRequest::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void serviceGetByNameRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* serviceGetByNameRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return serviceGetByNameRequest_descriptor_; +} + +const serviceGetByNameRequest& serviceGetByNameRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +serviceGetByNameRequest* serviceGetByNameRequest::default_instance_ = NULL; + +serviceGetByNameRequest* serviceGetByNameRequest::New() const { + return new serviceGetByNameRequest; +} + +void serviceGetByNameRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool serviceGetByNameRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void serviceGetByNameRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* serviceGetByNameRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int serviceGetByNameRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void serviceGetByNameRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const serviceGetByNameRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void serviceGetByNameRequest::MergeFrom(const serviceGetByNameRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void serviceGetByNameRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void serviceGetByNameRequest::CopyFrom(const serviceGetByNameRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool serviceGetByNameRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void serviceGetByNameRequest::Swap(serviceGetByNameRequest* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata serviceGetByNameRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = serviceGetByNameRequest_descriptor_; + metadata.reflection = serviceGetByNameRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int serviceGetByUUIDRequest::kNameFieldNumber; +#endif // !_MSC_VER + +serviceGetByUUIDRequest::serviceGetByUUIDRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void serviceGetByUUIDRequest::InitAsDefaultInstance() { +} + +serviceGetByUUIDRequest::serviceGetByUUIDRequest(const serviceGetByUUIDRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void serviceGetByUUIDRequest::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +serviceGetByUUIDRequest::~serviceGetByUUIDRequest() { + SharedDtor(); +} + +void serviceGetByUUIDRequest::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void serviceGetByUUIDRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* serviceGetByUUIDRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return serviceGetByUUIDRequest_descriptor_; +} + +const serviceGetByUUIDRequest& serviceGetByUUIDRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +serviceGetByUUIDRequest* serviceGetByUUIDRequest::default_instance_ = NULL; + +serviceGetByUUIDRequest* serviceGetByUUIDRequest::New() const { + return new serviceGetByUUIDRequest; +} + +void serviceGetByUUIDRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool serviceGetByUUIDRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void serviceGetByUUIDRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* serviceGetByUUIDRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int serviceGetByUUIDRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void serviceGetByUUIDRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const serviceGetByUUIDRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void serviceGetByUUIDRequest::MergeFrom(const serviceGetByUUIDRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void serviceGetByUUIDRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void serviceGetByUUIDRequest::CopyFrom(const serviceGetByUUIDRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool serviceGetByUUIDRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void serviceGetByUUIDRequest::Swap(serviceGetByUUIDRequest* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata serviceGetByUUIDRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = serviceGetByUUIDRequest_descriptor_; + metadata.reflection = serviceGetByUUIDRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int serviceGetByTypeRequest::kTypeFieldNumber; +#endif // !_MSC_VER + +serviceGetByTypeRequest::serviceGetByTypeRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void serviceGetByTypeRequest::InitAsDefaultInstance() { +} + +serviceGetByTypeRequest::serviceGetByTypeRequest(const serviceGetByTypeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void serviceGetByTypeRequest::SharedCtor() { + _cached_size_ = 0; + type_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +serviceGetByTypeRequest::~serviceGetByTypeRequest() { + SharedDtor(); +} + +void serviceGetByTypeRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void serviceGetByTypeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* serviceGetByTypeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return serviceGetByTypeRequest_descriptor_; +} + +const serviceGetByTypeRequest& serviceGetByTypeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +serviceGetByTypeRequest* serviceGetByTypeRequest::default_instance_ = NULL; + +serviceGetByTypeRequest* serviceGetByTypeRequest::New() const { + return new serviceGetByTypeRequest; +} + +void serviceGetByTypeRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + type_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool serviceGetByTypeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.ServiceType type = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::ServiceType_IsValid(value)) { + set_type(static_cast< ::xtreemfs::pbrpc::ServiceType >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void serviceGetByTypeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.ServiceType type = 1; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->type(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* serviceGetByTypeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.ServiceType type = 1; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->type(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int serviceGetByTypeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.ServiceType type = 1; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void serviceGetByTypeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const serviceGetByTypeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void serviceGetByTypeRequest::MergeFrom(const serviceGetByTypeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_type()) { + set_type(from.type()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void serviceGetByTypeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void serviceGetByTypeRequest::CopyFrom(const serviceGetByTypeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool serviceGetByTypeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void serviceGetByTypeRequest::Swap(serviceGetByTypeRequest* other) { + if (other != this) { + std::swap(type_, other->type_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata serviceGetByTypeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = serviceGetByTypeRequest_descriptor_; + metadata.reflection = serviceGetByTypeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int serviceRegisterRequest::kServiceFieldNumber; +#endif // !_MSC_VER + +serviceRegisterRequest::serviceRegisterRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void serviceRegisterRequest::InitAsDefaultInstance() { + service_ = const_cast< ::xtreemfs::pbrpc::Service*>(&::xtreemfs::pbrpc::Service::default_instance()); +} + +serviceRegisterRequest::serviceRegisterRequest(const serviceRegisterRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void serviceRegisterRequest::SharedCtor() { + _cached_size_ = 0; + service_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +serviceRegisterRequest::~serviceRegisterRequest() { + SharedDtor(); +} + +void serviceRegisterRequest::SharedDtor() { + if (this != default_instance_) { + delete service_; + } +} + +void serviceRegisterRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* serviceRegisterRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return serviceRegisterRequest_descriptor_; +} + +const serviceRegisterRequest& serviceRegisterRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +serviceRegisterRequest* serviceRegisterRequest::default_instance_ = NULL; + +serviceRegisterRequest* serviceRegisterRequest::New() const { + return new serviceRegisterRequest; +} + +void serviceRegisterRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_service()) { + if (service_ != NULL) service_->::xtreemfs::pbrpc::Service::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool serviceRegisterRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.Service service = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_service())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void serviceRegisterRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.Service service = 1; + if (has_service()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->service(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* serviceRegisterRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.Service service = 1; + if (has_service()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->service(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int serviceRegisterRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.Service service = 1; + if (has_service()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->service()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void serviceRegisterRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const serviceRegisterRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void serviceRegisterRequest::MergeFrom(const serviceRegisterRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_service()) { + mutable_service()->::xtreemfs::pbrpc::Service::MergeFrom(from.service()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void serviceRegisterRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void serviceRegisterRequest::CopyFrom(const serviceRegisterRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool serviceRegisterRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_service()) { + if (!this->service().IsInitialized()) return false; + } + return true; +} + +void serviceRegisterRequest::Swap(serviceRegisterRequest* other) { + if (other != this) { + std::swap(service_, other->service_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata serviceRegisterRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = serviceRegisterRequest_descriptor_; + metadata.reflection = serviceRegisterRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int serviceRegisterResponse::kNewVersionFieldNumber; +#endif // !_MSC_VER + +serviceRegisterResponse::serviceRegisterResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void serviceRegisterResponse::InitAsDefaultInstance() { +} + +serviceRegisterResponse::serviceRegisterResponse(const serviceRegisterResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void serviceRegisterResponse::SharedCtor() { + _cached_size_ = 0; + new_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +serviceRegisterResponse::~serviceRegisterResponse() { + SharedDtor(); +} + +void serviceRegisterResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void serviceRegisterResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* serviceRegisterResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return serviceRegisterResponse_descriptor_; +} + +const serviceRegisterResponse& serviceRegisterResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +serviceRegisterResponse* serviceRegisterResponse::default_instance_ = NULL; + +serviceRegisterResponse* serviceRegisterResponse::New() const { + return new serviceRegisterResponse; +} + +void serviceRegisterResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + new_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool serviceRegisterResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 new_version = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &new_version_))); + set_has_new_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void serviceRegisterResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 new_version = 1; + if (has_new_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* serviceRegisterResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 new_version = 1; + if (has_new_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int serviceRegisterResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 new_version = 1; + if (has_new_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void serviceRegisterResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const serviceRegisterResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void serviceRegisterResponse::MergeFrom(const serviceRegisterResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_new_version()) { + set_new_version(from.new_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void serviceRegisterResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void serviceRegisterResponse::CopyFrom(const serviceRegisterResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool serviceRegisterResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void serviceRegisterResponse::Swap(serviceRegisterResponse* other) { + if (other != this) { + std::swap(new_version_, other->new_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata serviceRegisterResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = serviceRegisterResponse_descriptor_; + metadata.reflection = serviceRegisterResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int configurationGetRequest::kUuidFieldNumber; +#endif // !_MSC_VER + +configurationGetRequest::configurationGetRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void configurationGetRequest::InitAsDefaultInstance() { +} + +configurationGetRequest::configurationGetRequest(const configurationGetRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void configurationGetRequest::SharedCtor() { + _cached_size_ = 0; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +configurationGetRequest::~configurationGetRequest() { + SharedDtor(); +} + +void configurationGetRequest::SharedDtor() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (this != default_instance_) { + } +} + +void configurationGetRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* configurationGetRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return configurationGetRequest_descriptor_; +} + +const configurationGetRequest& configurationGetRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +configurationGetRequest* configurationGetRequest::default_instance_ = NULL; + +configurationGetRequest* configurationGetRequest::New() const { + return new configurationGetRequest; +} + +void configurationGetRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_uuid()) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool configurationGetRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string uuid = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void configurationGetRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->uuid(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* configurationGetRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string uuid = 1; + if (has_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->uuid().data(), this->uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->uuid(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int configurationGetRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string uuid = 1; + if (has_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->uuid()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void configurationGetRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const configurationGetRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void configurationGetRequest::MergeFrom(const configurationGetRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_uuid()) { + set_uuid(from.uuid()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void configurationGetRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void configurationGetRequest::CopyFrom(const configurationGetRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool configurationGetRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void configurationGetRequest::Swap(configurationGetRequest* other) { + if (other != this) { + std::swap(uuid_, other->uuid_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata configurationGetRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = configurationGetRequest_descriptor_; + metadata.reflection = configurationGetRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int configurationSetResponse::kNewVersionFieldNumber; +#endif // !_MSC_VER + +configurationSetResponse::configurationSetResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void configurationSetResponse::InitAsDefaultInstance() { +} + +configurationSetResponse::configurationSetResponse(const configurationSetResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void configurationSetResponse::SharedCtor() { + _cached_size_ = 0; + new_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +configurationSetResponse::~configurationSetResponse() { + SharedDtor(); +} + +void configurationSetResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void configurationSetResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* configurationSetResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return configurationSetResponse_descriptor_; +} + +const configurationSetResponse& configurationSetResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + return *default_instance_; +} + +configurationSetResponse* configurationSetResponse::default_instance_ = NULL; + +configurationSetResponse* configurationSetResponse::New() const { + return new configurationSetResponse; +} + +void configurationSetResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + new_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool configurationSetResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional fixed64 new_version = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &new_version_))); + set_has_new_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void configurationSetResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional fixed64 new_version = 1; + if (has_new_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* configurationSetResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional fixed64 new_version = 1; + if (has_new_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int configurationSetResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed64 new_version = 1; + if (has_new_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void configurationSetResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const configurationSetResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void configurationSetResponse::MergeFrom(const configurationSetResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_new_version()) { + set_new_version(from.new_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void configurationSetResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void configurationSetResponse::CopyFrom(const configurationSetResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool configurationSetResponse::IsInitialized() const { + + return true; +} + +void configurationSetResponse::Swap(configurationSetResponse* other) { + if (other != this) { + std::swap(new_version_, other->new_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata configurationSetResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = configurationSetResponse_descriptor_; + metadata.reflection = configurationSetResponse_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +// @@protoc_insertion_point(global_scope) diff --git a/cpp/generated/xtreemfs/DIR.pb.h b/cpp/generated/xtreemfs/DIR.pb.h new file mode 100644 index 0000000..0dbba44 --- /dev/null +++ b/cpp/generated/xtreemfs/DIR.pb.h @@ -0,0 +1,3602 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: xtreemfs/DIR.proto + +#ifndef PROTOBUF_xtreemfs_2fDIR_2eproto__INCLUDED +#define PROTOBUF_xtreemfs_2fDIR_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2005000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include "include/PBRPC.pb.h" +#include "include/Common.pb.h" +#include "xtreemfs/GlobalTypes.pb.h" +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); +void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); +void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + +class AddressMapping; +class AddressMappingSet; +class DirService; +class ServiceDataMap; +class Service; +class ServiceSet; +class Configuration; +class addressMappingGetRequest; +class addressMappingGetResponse; +class addressMappingSetResponse; +class globalTimeSGetResponse; +class serviceDeregisterRequest; +class serviceGetByNameRequest; +class serviceGetByUUIDRequest; +class serviceGetByTypeRequest; +class serviceRegisterRequest; +class serviceRegisterResponse; +class configurationGetRequest; +class configurationSetResponse; + +enum ServiceType { + SERVICE_TYPE_MIXED = 0, + SERVICE_TYPE_MRC = 1, + SERVICE_TYPE_OSD = 2, + SERVICE_TYPE_VOLUME = 3, + SERVICE_TYPE_DIR = 4 +}; +bool ServiceType_IsValid(int value); +const ServiceType ServiceType_MIN = SERVICE_TYPE_MIXED; +const ServiceType ServiceType_MAX = SERVICE_TYPE_DIR; +const int ServiceType_ARRAYSIZE = ServiceType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ServiceType_descriptor(); +inline const ::std::string& ServiceType_Name(ServiceType value) { + return ::google::protobuf::internal::NameOfEnum( + ServiceType_descriptor(), value); +} +inline bool ServiceType_Parse( + const ::std::string& name, ServiceType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ServiceType_descriptor(), name, value); +} +enum ServiceStatus { + SERVICE_STATUS_AVAIL = 0, + SERVICE_STATUS_TO_BE_REMOVED = 1, + SERVICE_STATUS_REMOVED = 2 +}; +bool ServiceStatus_IsValid(int value); +const ServiceStatus ServiceStatus_MIN = SERVICE_STATUS_AVAIL; +const ServiceStatus ServiceStatus_MAX = SERVICE_STATUS_REMOVED; +const int ServiceStatus_ARRAYSIZE = ServiceStatus_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor(); +inline const ::std::string& ServiceStatus_Name(ServiceStatus value) { + return ::google::protobuf::internal::NameOfEnum( + ServiceStatus_descriptor(), value); +} +inline bool ServiceStatus_Parse( + const ::std::string& name, ServiceStatus* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ServiceStatus_descriptor(), name, value); +} +// =================================================================== + +class AddressMapping : public ::google::protobuf::Message { + public: + AddressMapping(); + virtual ~AddressMapping(); + + AddressMapping(const AddressMapping& from); + + inline AddressMapping& operator=(const AddressMapping& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AddressMapping& default_instance(); + + void Swap(AddressMapping* other); + + // implements Message ---------------------------------------------- + + AddressMapping* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AddressMapping& from); + void MergeFrom(const AddressMapping& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string uuid = 1; + inline bool has_uuid() const; + inline void clear_uuid(); + static const int kUuidFieldNumber = 1; + inline const ::std::string& uuid() const; + inline void set_uuid(const ::std::string& value); + inline void set_uuid(const char* value); + inline void set_uuid(const char* value, size_t size); + inline ::std::string* mutable_uuid(); + inline ::std::string* release_uuid(); + inline void set_allocated_uuid(::std::string* uuid); + + // required fixed64 version = 2; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 2; + inline ::google::protobuf::uint64 version() const; + inline void set_version(::google::protobuf::uint64 value); + + // required string protocol = 3; + inline bool has_protocol() const; + inline void clear_protocol(); + static const int kProtocolFieldNumber = 3; + inline const ::std::string& protocol() const; + inline void set_protocol(const ::std::string& value); + inline void set_protocol(const char* value); + inline void set_protocol(const char* value, size_t size); + inline ::std::string* mutable_protocol(); + inline ::std::string* release_protocol(); + inline void set_allocated_protocol(::std::string* protocol); + + // required string address = 4; + inline bool has_address() const; + inline void clear_address(); + static const int kAddressFieldNumber = 4; + inline const ::std::string& address() const; + inline void set_address(const ::std::string& value); + inline void set_address(const char* value); + inline void set_address(const char* value, size_t size); + inline ::std::string* mutable_address(); + inline ::std::string* release_address(); + inline void set_allocated_address(::std::string* address); + + // required fixed32 port = 5; + inline bool has_port() const; + inline void clear_port(); + static const int kPortFieldNumber = 5; + inline ::google::protobuf::uint32 port() const; + inline void set_port(::google::protobuf::uint32 value); + + // required string match_network = 6; + inline bool has_match_network() const; + inline void clear_match_network(); + static const int kMatchNetworkFieldNumber = 6; + inline const ::std::string& match_network() const; + inline void set_match_network(const ::std::string& value); + inline void set_match_network(const char* value); + inline void set_match_network(const char* value, size_t size); + inline ::std::string* mutable_match_network(); + inline ::std::string* release_match_network(); + inline void set_allocated_match_network(::std::string* match_network); + + // required fixed32 ttl_s = 7; + inline bool has_ttl_s() const; + inline void clear_ttl_s(); + static const int kTtlSFieldNumber = 7; + inline ::google::protobuf::uint32 ttl_s() const; + inline void set_ttl_s(::google::protobuf::uint32 value); + + // required string uri = 8; + inline bool has_uri() const; + inline void clear_uri(); + static const int kUriFieldNumber = 8; + inline const ::std::string& uri() const; + inline void set_uri(const ::std::string& value); + inline void set_uri(const char* value); + inline void set_uri(const char* value, size_t size); + inline ::std::string* mutable_uri(); + inline ::std::string* release_uri(); + inline void set_allocated_uri(::std::string* uri); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.AddressMapping) + private: + inline void set_has_uuid(); + inline void clear_has_uuid(); + inline void set_has_version(); + inline void clear_has_version(); + inline void set_has_protocol(); + inline void clear_has_protocol(); + inline void set_has_address(); + inline void clear_has_address(); + inline void set_has_port(); + inline void clear_has_port(); + inline void set_has_match_network(); + inline void clear_has_match_network(); + inline void set_has_ttl_s(); + inline void clear_has_ttl_s(); + inline void set_has_uri(); + inline void clear_has_uri(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* uuid_; + ::google::protobuf::uint64 version_; + ::std::string* protocol_; + ::std::string* address_; + ::std::string* match_network_; + ::google::protobuf::uint32 port_; + ::google::protobuf::uint32 ttl_s_; + ::std::string* uri_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static AddressMapping* default_instance_; +}; +// ------------------------------------------------------------------- + +class AddressMappingSet : public ::google::protobuf::Message { + public: + AddressMappingSet(); + virtual ~AddressMappingSet(); + + AddressMappingSet(const AddressMappingSet& from); + + inline AddressMappingSet& operator=(const AddressMappingSet& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AddressMappingSet& default_instance(); + + void Swap(AddressMappingSet* other); + + // implements Message ---------------------------------------------- + + AddressMappingSet* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AddressMappingSet& from); + void MergeFrom(const AddressMappingSet& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1; + inline int mappings_size() const; + inline void clear_mappings(); + static const int kMappingsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::AddressMapping& mappings(int index) const; + inline ::xtreemfs::pbrpc::AddressMapping* mutable_mappings(int index); + inline ::xtreemfs::pbrpc::AddressMapping* add_mappings(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping >& + mappings() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping >* + mutable_mappings(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.AddressMappingSet) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping > mappings_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static AddressMappingSet* default_instance_; +}; +// ------------------------------------------------------------------- + +class DirService : public ::google::protobuf::Message { + public: + DirService(); + virtual ~DirService(); + + DirService(const DirService& from); + + inline DirService& operator=(const DirService& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DirService& default_instance(); + + void Swap(DirService* other); + + // implements Message ---------------------------------------------- + + DirService* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DirService& from); + void MergeFrom(const DirService& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string address = 1; + inline bool has_address() const; + inline void clear_address(); + static const int kAddressFieldNumber = 1; + inline const ::std::string& address() const; + inline void set_address(const ::std::string& value); + inline void set_address(const char* value); + inline void set_address(const char* value, size_t size); + inline ::std::string* mutable_address(); + inline ::std::string* release_address(); + inline void set_allocated_address(::std::string* address); + + // required fixed32 port = 2; + inline bool has_port() const; + inline void clear_port(); + static const int kPortFieldNumber = 2; + inline ::google::protobuf::uint32 port() const; + inline void set_port(::google::protobuf::uint32 value); + + // required string protocol = 3; + inline bool has_protocol() const; + inline void clear_protocol(); + static const int kProtocolFieldNumber = 3; + inline const ::std::string& protocol() const; + inline void set_protocol(const ::std::string& value); + inline void set_protocol(const char* value); + inline void set_protocol(const char* value, size_t size); + inline ::std::string* mutable_protocol(); + inline ::std::string* release_protocol(); + inline void set_allocated_protocol(::std::string* protocol); + + // required fixed32 interface_version = 4; + inline bool has_interface_version() const; + inline void clear_interface_version(); + static const int kInterfaceVersionFieldNumber = 4; + inline ::google::protobuf::uint32 interface_version() const; + inline void set_interface_version(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.DirService) + private: + inline void set_has_address(); + inline void clear_has_address(); + inline void set_has_port(); + inline void clear_has_port(); + inline void set_has_protocol(); + inline void clear_has_protocol(); + inline void set_has_interface_version(); + inline void clear_has_interface_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* address_; + ::std::string* protocol_; + ::google::protobuf::uint32 port_; + ::google::protobuf::uint32 interface_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static DirService* default_instance_; +}; +// ------------------------------------------------------------------- + +class ServiceDataMap : public ::google::protobuf::Message { + public: + ServiceDataMap(); + virtual ~ServiceDataMap(); + + ServiceDataMap(const ServiceDataMap& from); + + inline ServiceDataMap& operator=(const ServiceDataMap& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ServiceDataMap& default_instance(); + + void Swap(ServiceDataMap* other); + + // implements Message ---------------------------------------------- + + ServiceDataMap* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ServiceDataMap& from); + void MergeFrom(const ServiceDataMap& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .xtreemfs.pbrpc.KeyValuePair data = 1; + inline int data_size() const; + inline void clear_data(); + static const int kDataFieldNumber = 1; + inline const ::xtreemfs::pbrpc::KeyValuePair& data(int index) const; + inline ::xtreemfs::pbrpc::KeyValuePair* mutable_data(int index); + inline ::xtreemfs::pbrpc::KeyValuePair* add_data(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >& + data() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >* + mutable_data(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ServiceDataMap) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair > data_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static ServiceDataMap* default_instance_; +}; +// ------------------------------------------------------------------- + +class Service : public ::google::protobuf::Message { + public: + Service(); + virtual ~Service(); + + Service(const Service& from); + + inline Service& operator=(const Service& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Service& default_instance(); + + void Swap(Service* other); + + // implements Message ---------------------------------------------- + + Service* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Service& from); + void MergeFrom(const Service& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.ServiceType type = 1; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 1; + inline ::xtreemfs::pbrpc::ServiceType type() const; + inline void set_type(::xtreemfs::pbrpc::ServiceType value); + + // required string uuid = 2; + inline bool has_uuid() const; + inline void clear_uuid(); + static const int kUuidFieldNumber = 2; + inline const ::std::string& uuid() const; + inline void set_uuid(const ::std::string& value); + inline void set_uuid(const char* value); + inline void set_uuid(const char* value, size_t size); + inline ::std::string* mutable_uuid(); + inline ::std::string* release_uuid(); + inline void set_allocated_uuid(::std::string* uuid); + + // required fixed64 version = 3; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 3; + inline ::google::protobuf::uint64 version() const; + inline void set_version(::google::protobuf::uint64 value); + + // required string name = 4; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 4; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // required fixed64 last_updated_s = 5; + inline bool has_last_updated_s() const; + inline void clear_last_updated_s(); + static const int kLastUpdatedSFieldNumber = 5; + inline ::google::protobuf::uint64 last_updated_s() const; + inline void set_last_updated_s(::google::protobuf::uint64 value); + + // required .xtreemfs.pbrpc.ServiceDataMap data = 6; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 6; + inline const ::xtreemfs::pbrpc::ServiceDataMap& data() const; + inline ::xtreemfs::pbrpc::ServiceDataMap* mutable_data(); + inline ::xtreemfs::pbrpc::ServiceDataMap* release_data(); + inline void set_allocated_data(::xtreemfs::pbrpc::ServiceDataMap* data); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Service) + private: + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_uuid(); + inline void clear_has_uuid(); + inline void set_has_version(); + inline void clear_has_version(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_last_updated_s(); + inline void clear_has_last_updated_s(); + inline void set_has_data(); + inline void clear_has_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* uuid_; + ::google::protobuf::uint64 version_; + ::std::string* name_; + ::google::protobuf::uint64 last_updated_s_; + ::xtreemfs::pbrpc::ServiceDataMap* data_; + int type_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static Service* default_instance_; +}; +// ------------------------------------------------------------------- + +class ServiceSet : public ::google::protobuf::Message { + public: + ServiceSet(); + virtual ~ServiceSet(); + + ServiceSet(const ServiceSet& from); + + inline ServiceSet& operator=(const ServiceSet& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ServiceSet& default_instance(); + + void Swap(ServiceSet* other); + + // implements Message ---------------------------------------------- + + ServiceSet* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ServiceSet& from); + void MergeFrom(const ServiceSet& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .xtreemfs.pbrpc.Service services = 1; + inline int services_size() const; + inline void clear_services(); + static const int kServicesFieldNumber = 1; + inline const ::xtreemfs::pbrpc::Service& services(int index) const; + inline ::xtreemfs::pbrpc::Service* mutable_services(int index); + inline ::xtreemfs::pbrpc::Service* add_services(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service >& + services() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service >* + mutable_services(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ServiceSet) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service > services_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static ServiceSet* default_instance_; +}; +// ------------------------------------------------------------------- + +class Configuration : public ::google::protobuf::Message { + public: + Configuration(); + virtual ~Configuration(); + + Configuration(const Configuration& from); + + inline Configuration& operator=(const Configuration& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Configuration& default_instance(); + + void Swap(Configuration* other); + + // implements Message ---------------------------------------------- + + Configuration* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Configuration& from); + void MergeFrom(const Configuration& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string uuid = 1; + inline bool has_uuid() const; + inline void clear_uuid(); + static const int kUuidFieldNumber = 1; + inline const ::std::string& uuid() const; + inline void set_uuid(const ::std::string& value); + inline void set_uuid(const char* value); + inline void set_uuid(const char* value, size_t size); + inline ::std::string* mutable_uuid(); + inline ::std::string* release_uuid(); + inline void set_allocated_uuid(::std::string* uuid); + + // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2; + inline int parameter_size() const; + inline void clear_parameter(); + static const int kParameterFieldNumber = 2; + inline const ::xtreemfs::pbrpc::KeyValuePair& parameter(int index) const; + inline ::xtreemfs::pbrpc::KeyValuePair* mutable_parameter(int index); + inline ::xtreemfs::pbrpc::KeyValuePair* add_parameter(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >& + parameter() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >* + mutable_parameter(); + + // required fixed64 version = 3; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 3; + inline ::google::protobuf::uint64 version() const; + inline void set_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Configuration) + private: + inline void set_has_uuid(); + inline void clear_has_uuid(); + inline void set_has_version(); + inline void clear_has_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* uuid_; + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair > parameter_; + ::google::protobuf::uint64 version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static Configuration* default_instance_; +}; +// ------------------------------------------------------------------- + +class addressMappingGetRequest : public ::google::protobuf::Message { + public: + addressMappingGetRequest(); + virtual ~addressMappingGetRequest(); + + addressMappingGetRequest(const addressMappingGetRequest& from); + + inline addressMappingGetRequest& operator=(const addressMappingGetRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const addressMappingGetRequest& default_instance(); + + void Swap(addressMappingGetRequest* other); + + // implements Message ---------------------------------------------- + + addressMappingGetRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const addressMappingGetRequest& from); + void MergeFrom(const addressMappingGetRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string uuid = 1; + inline bool has_uuid() const; + inline void clear_uuid(); + static const int kUuidFieldNumber = 1; + inline const ::std::string& uuid() const; + inline void set_uuid(const ::std::string& value); + inline void set_uuid(const char* value); + inline void set_uuid(const char* value, size_t size); + inline ::std::string* mutable_uuid(); + inline ::std::string* release_uuid(); + inline void set_allocated_uuid(::std::string* uuid); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.addressMappingGetRequest) + private: + inline void set_has_uuid(); + inline void clear_has_uuid(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* uuid_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static addressMappingGetRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class addressMappingGetResponse : public ::google::protobuf::Message { + public: + addressMappingGetResponse(); + virtual ~addressMappingGetResponse(); + + addressMappingGetResponse(const addressMappingGetResponse& from); + + inline addressMappingGetResponse& operator=(const addressMappingGetResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const addressMappingGetResponse& default_instance(); + + void Swap(addressMappingGetResponse* other); + + // implements Message ---------------------------------------------- + + addressMappingGetResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const addressMappingGetResponse& from); + void MergeFrom(const addressMappingGetResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .xtreemfs.pbrpc.AddressMappingSet result = 1; + inline bool has_result() const; + inline void clear_result(); + static const int kResultFieldNumber = 1; + inline const ::xtreemfs::pbrpc::AddressMappingSet& result() const; + inline ::xtreemfs::pbrpc::AddressMappingSet* mutable_result(); + inline ::xtreemfs::pbrpc::AddressMappingSet* release_result(); + inline void set_allocated_result(::xtreemfs::pbrpc::AddressMappingSet* result); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.addressMappingGetResponse) + private: + inline void set_has_result(); + inline void clear_has_result(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::AddressMappingSet* result_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static addressMappingGetResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class addressMappingSetResponse : public ::google::protobuf::Message { + public: + addressMappingSetResponse(); + virtual ~addressMappingSetResponse(); + + addressMappingSetResponse(const addressMappingSetResponse& from); + + inline addressMappingSetResponse& operator=(const addressMappingSetResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const addressMappingSetResponse& default_instance(); + + void Swap(addressMappingSetResponse* other); + + // implements Message ---------------------------------------------- + + addressMappingSetResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const addressMappingSetResponse& from); + void MergeFrom(const addressMappingSetResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed64 new_version = 1; + inline bool has_new_version() const; + inline void clear_new_version(); + static const int kNewVersionFieldNumber = 1; + inline ::google::protobuf::uint64 new_version() const; + inline void set_new_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.addressMappingSetResponse) + private: + inline void set_has_new_version(); + inline void clear_has_new_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 new_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static addressMappingSetResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class globalTimeSGetResponse : public ::google::protobuf::Message { + public: + globalTimeSGetResponse(); + virtual ~globalTimeSGetResponse(); + + globalTimeSGetResponse(const globalTimeSGetResponse& from); + + inline globalTimeSGetResponse& operator=(const globalTimeSGetResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const globalTimeSGetResponse& default_instance(); + + void Swap(globalTimeSGetResponse* other); + + // implements Message ---------------------------------------------- + + globalTimeSGetResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const globalTimeSGetResponse& from); + void MergeFrom(const globalTimeSGetResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 time_in_seconds = 1; + inline bool has_time_in_seconds() const; + inline void clear_time_in_seconds(); + static const int kTimeInSecondsFieldNumber = 1; + inline ::google::protobuf::uint64 time_in_seconds() const; + inline void set_time_in_seconds(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.globalTimeSGetResponse) + private: + inline void set_has_time_in_seconds(); + inline void clear_has_time_in_seconds(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 time_in_seconds_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static globalTimeSGetResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class serviceDeregisterRequest : public ::google::protobuf::Message { + public: + serviceDeregisterRequest(); + virtual ~serviceDeregisterRequest(); + + serviceDeregisterRequest(const serviceDeregisterRequest& from); + + inline serviceDeregisterRequest& operator=(const serviceDeregisterRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const serviceDeregisterRequest& default_instance(); + + void Swap(serviceDeregisterRequest* other); + + // implements Message ---------------------------------------------- + + serviceDeregisterRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const serviceDeregisterRequest& from); + void MergeFrom(const serviceDeregisterRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string uuid = 1; + inline bool has_uuid() const; + inline void clear_uuid(); + static const int kUuidFieldNumber = 1; + inline const ::std::string& uuid() const; + inline void set_uuid(const ::std::string& value); + inline void set_uuid(const char* value); + inline void set_uuid(const char* value, size_t size); + inline ::std::string* mutable_uuid(); + inline ::std::string* release_uuid(); + inline void set_allocated_uuid(::std::string* uuid); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceDeregisterRequest) + private: + inline void set_has_uuid(); + inline void clear_has_uuid(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* uuid_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static serviceDeregisterRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class serviceGetByNameRequest : public ::google::protobuf::Message { + public: + serviceGetByNameRequest(); + virtual ~serviceGetByNameRequest(); + + serviceGetByNameRequest(const serviceGetByNameRequest& from); + + inline serviceGetByNameRequest& operator=(const serviceGetByNameRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const serviceGetByNameRequest& default_instance(); + + void Swap(serviceGetByNameRequest* other); + + // implements Message ---------------------------------------------- + + serviceGetByNameRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const serviceGetByNameRequest& from); + void MergeFrom(const serviceGetByNameRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceGetByNameRequest) + private: + inline void set_has_name(); + inline void clear_has_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* name_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static serviceGetByNameRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class serviceGetByUUIDRequest : public ::google::protobuf::Message { + public: + serviceGetByUUIDRequest(); + virtual ~serviceGetByUUIDRequest(); + + serviceGetByUUIDRequest(const serviceGetByUUIDRequest& from); + + inline serviceGetByUUIDRequest& operator=(const serviceGetByUUIDRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const serviceGetByUUIDRequest& default_instance(); + + void Swap(serviceGetByUUIDRequest* other); + + // implements Message ---------------------------------------------- + + serviceGetByUUIDRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const serviceGetByUUIDRequest& from); + void MergeFrom(const serviceGetByUUIDRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceGetByUUIDRequest) + private: + inline void set_has_name(); + inline void clear_has_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* name_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static serviceGetByUUIDRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class serviceGetByTypeRequest : public ::google::protobuf::Message { + public: + serviceGetByTypeRequest(); + virtual ~serviceGetByTypeRequest(); + + serviceGetByTypeRequest(const serviceGetByTypeRequest& from); + + inline serviceGetByTypeRequest& operator=(const serviceGetByTypeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const serviceGetByTypeRequest& default_instance(); + + void Swap(serviceGetByTypeRequest* other); + + // implements Message ---------------------------------------------- + + serviceGetByTypeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const serviceGetByTypeRequest& from); + void MergeFrom(const serviceGetByTypeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.ServiceType type = 1; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 1; + inline ::xtreemfs::pbrpc::ServiceType type() const; + inline void set_type(::xtreemfs::pbrpc::ServiceType value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceGetByTypeRequest) + private: + inline void set_has_type(); + inline void clear_has_type(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + int type_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static serviceGetByTypeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class serviceRegisterRequest : public ::google::protobuf::Message { + public: + serviceRegisterRequest(); + virtual ~serviceRegisterRequest(); + + serviceRegisterRequest(const serviceRegisterRequest& from); + + inline serviceRegisterRequest& operator=(const serviceRegisterRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const serviceRegisterRequest& default_instance(); + + void Swap(serviceRegisterRequest* other); + + // implements Message ---------------------------------------------- + + serviceRegisterRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const serviceRegisterRequest& from); + void MergeFrom(const serviceRegisterRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.Service service = 1; + inline bool has_service() const; + inline void clear_service(); + static const int kServiceFieldNumber = 1; + inline const ::xtreemfs::pbrpc::Service& service() const; + inline ::xtreemfs::pbrpc::Service* mutable_service(); + inline ::xtreemfs::pbrpc::Service* release_service(); + inline void set_allocated_service(::xtreemfs::pbrpc::Service* service); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceRegisterRequest) + private: + inline void set_has_service(); + inline void clear_has_service(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::Service* service_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static serviceRegisterRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class serviceRegisterResponse : public ::google::protobuf::Message { + public: + serviceRegisterResponse(); + virtual ~serviceRegisterResponse(); + + serviceRegisterResponse(const serviceRegisterResponse& from); + + inline serviceRegisterResponse& operator=(const serviceRegisterResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const serviceRegisterResponse& default_instance(); + + void Swap(serviceRegisterResponse* other); + + // implements Message ---------------------------------------------- + + serviceRegisterResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const serviceRegisterResponse& from); + void MergeFrom(const serviceRegisterResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 new_version = 1; + inline bool has_new_version() const; + inline void clear_new_version(); + static const int kNewVersionFieldNumber = 1; + inline ::google::protobuf::uint64 new_version() const; + inline void set_new_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceRegisterResponse) + private: + inline void set_has_new_version(); + inline void clear_has_new_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 new_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static serviceRegisterResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class configurationGetRequest : public ::google::protobuf::Message { + public: + configurationGetRequest(); + virtual ~configurationGetRequest(); + + configurationGetRequest(const configurationGetRequest& from); + + inline configurationGetRequest& operator=(const configurationGetRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const configurationGetRequest& default_instance(); + + void Swap(configurationGetRequest* other); + + // implements Message ---------------------------------------------- + + configurationGetRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const configurationGetRequest& from); + void MergeFrom(const configurationGetRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string uuid = 1; + inline bool has_uuid() const; + inline void clear_uuid(); + static const int kUuidFieldNumber = 1; + inline const ::std::string& uuid() const; + inline void set_uuid(const ::std::string& value); + inline void set_uuid(const char* value); + inline void set_uuid(const char* value, size_t size); + inline ::std::string* mutable_uuid(); + inline ::std::string* release_uuid(); + inline void set_allocated_uuid(::std::string* uuid); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.configurationGetRequest) + private: + inline void set_has_uuid(); + inline void clear_has_uuid(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* uuid_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static configurationGetRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class configurationSetResponse : public ::google::protobuf::Message { + public: + configurationSetResponse(); + virtual ~configurationSetResponse(); + + configurationSetResponse(const configurationSetResponse& from); + + inline configurationSetResponse& operator=(const configurationSetResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const configurationSetResponse& default_instance(); + + void Swap(configurationSetResponse* other); + + // implements Message ---------------------------------------------- + + configurationSetResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const configurationSetResponse& from); + void MergeFrom(const configurationSetResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed64 new_version = 1; + inline bool has_new_version() const; + inline void clear_new_version(); + static const int kNewVersionFieldNumber = 1; + inline ::google::protobuf::uint64 new_version() const; + inline void set_new_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.configurationSetResponse) + private: + inline void set_has_new_version(); + inline void clear_has_new_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 new_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto(); + + void InitAsDefaultInstance(); + static configurationSetResponse* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// AddressMapping + +// required string uuid = 1; +inline bool AddressMapping::has_uuid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AddressMapping::set_has_uuid() { + _has_bits_[0] |= 0x00000001u; +} +inline void AddressMapping::clear_has_uuid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AddressMapping::clear_uuid() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + clear_has_uuid(); +} +inline const ::std::string& AddressMapping::uuid() const { + return *uuid_; +} +inline void AddressMapping::set_uuid(const ::std::string& value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void AddressMapping::set_uuid(const char* value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void AddressMapping::set_uuid(const char* value, size_t size) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* AddressMapping::mutable_uuid() { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + return uuid_; +} +inline ::std::string* AddressMapping::release_uuid() { + clear_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = uuid_; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void AddressMapping::set_allocated_uuid(::std::string* uuid) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (uuid) { + set_has_uuid(); + uuid_ = uuid; + } else { + clear_has_uuid(); + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 version = 2; +inline bool AddressMapping::has_version() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AddressMapping::set_has_version() { + _has_bits_[0] |= 0x00000002u; +} +inline void AddressMapping::clear_has_version() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AddressMapping::clear_version() { + version_ = GOOGLE_ULONGLONG(0); + clear_has_version(); +} +inline ::google::protobuf::uint64 AddressMapping::version() const { + return version_; +} +inline void AddressMapping::set_version(::google::protobuf::uint64 value) { + set_has_version(); + version_ = value; +} + +// required string protocol = 3; +inline bool AddressMapping::has_protocol() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AddressMapping::set_has_protocol() { + _has_bits_[0] |= 0x00000004u; +} +inline void AddressMapping::clear_has_protocol() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AddressMapping::clear_protocol() { + if (protocol_ != &::google::protobuf::internal::kEmptyString) { + protocol_->clear(); + } + clear_has_protocol(); +} +inline const ::std::string& AddressMapping::protocol() const { + return *protocol_; +} +inline void AddressMapping::set_protocol(const ::std::string& value) { + set_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + protocol_ = new ::std::string; + } + protocol_->assign(value); +} +inline void AddressMapping::set_protocol(const char* value) { + set_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + protocol_ = new ::std::string; + } + protocol_->assign(value); +} +inline void AddressMapping::set_protocol(const char* value, size_t size) { + set_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + protocol_ = new ::std::string; + } + protocol_->assign(reinterpret_cast(value), size); +} +inline ::std::string* AddressMapping::mutable_protocol() { + set_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + protocol_ = new ::std::string; + } + return protocol_; +} +inline ::std::string* AddressMapping::release_protocol() { + clear_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = protocol_; + protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void AddressMapping::set_allocated_protocol(::std::string* protocol) { + if (protocol_ != &::google::protobuf::internal::kEmptyString) { + delete protocol_; + } + if (protocol) { + set_has_protocol(); + protocol_ = protocol; + } else { + clear_has_protocol(); + protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string address = 4; +inline bool AddressMapping::has_address() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AddressMapping::set_has_address() { + _has_bits_[0] |= 0x00000008u; +} +inline void AddressMapping::clear_has_address() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AddressMapping::clear_address() { + if (address_ != &::google::protobuf::internal::kEmptyString) { + address_->clear(); + } + clear_has_address(); +} +inline const ::std::string& AddressMapping::address() const { + return *address_; +} +inline void AddressMapping::set_address(const ::std::string& value) { + set_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + address_ = new ::std::string; + } + address_->assign(value); +} +inline void AddressMapping::set_address(const char* value) { + set_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + address_ = new ::std::string; + } + address_->assign(value); +} +inline void AddressMapping::set_address(const char* value, size_t size) { + set_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + address_ = new ::std::string; + } + address_->assign(reinterpret_cast(value), size); +} +inline ::std::string* AddressMapping::mutable_address() { + set_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + address_ = new ::std::string; + } + return address_; +} +inline ::std::string* AddressMapping::release_address() { + clear_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = address_; + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void AddressMapping::set_allocated_address(::std::string* address) { + if (address_ != &::google::protobuf::internal::kEmptyString) { + delete address_; + } + if (address) { + set_has_address(); + address_ = address; + } else { + clear_has_address(); + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 port = 5; +inline bool AddressMapping::has_port() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void AddressMapping::set_has_port() { + _has_bits_[0] |= 0x00000010u; +} +inline void AddressMapping::clear_has_port() { + _has_bits_[0] &= ~0x00000010u; +} +inline void AddressMapping::clear_port() { + port_ = 0u; + clear_has_port(); +} +inline ::google::protobuf::uint32 AddressMapping::port() const { + return port_; +} +inline void AddressMapping::set_port(::google::protobuf::uint32 value) { + set_has_port(); + port_ = value; +} + +// required string match_network = 6; +inline bool AddressMapping::has_match_network() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void AddressMapping::set_has_match_network() { + _has_bits_[0] |= 0x00000020u; +} +inline void AddressMapping::clear_has_match_network() { + _has_bits_[0] &= ~0x00000020u; +} +inline void AddressMapping::clear_match_network() { + if (match_network_ != &::google::protobuf::internal::kEmptyString) { + match_network_->clear(); + } + clear_has_match_network(); +} +inline const ::std::string& AddressMapping::match_network() const { + return *match_network_; +} +inline void AddressMapping::set_match_network(const ::std::string& value) { + set_has_match_network(); + if (match_network_ == &::google::protobuf::internal::kEmptyString) { + match_network_ = new ::std::string; + } + match_network_->assign(value); +} +inline void AddressMapping::set_match_network(const char* value) { + set_has_match_network(); + if (match_network_ == &::google::protobuf::internal::kEmptyString) { + match_network_ = new ::std::string; + } + match_network_->assign(value); +} +inline void AddressMapping::set_match_network(const char* value, size_t size) { + set_has_match_network(); + if (match_network_ == &::google::protobuf::internal::kEmptyString) { + match_network_ = new ::std::string; + } + match_network_->assign(reinterpret_cast(value), size); +} +inline ::std::string* AddressMapping::mutable_match_network() { + set_has_match_network(); + if (match_network_ == &::google::protobuf::internal::kEmptyString) { + match_network_ = new ::std::string; + } + return match_network_; +} +inline ::std::string* AddressMapping::release_match_network() { + clear_has_match_network(); + if (match_network_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = match_network_; + match_network_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void AddressMapping::set_allocated_match_network(::std::string* match_network) { + if (match_network_ != &::google::protobuf::internal::kEmptyString) { + delete match_network_; + } + if (match_network) { + set_has_match_network(); + match_network_ = match_network; + } else { + clear_has_match_network(); + match_network_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 ttl_s = 7; +inline bool AddressMapping::has_ttl_s() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void AddressMapping::set_has_ttl_s() { + _has_bits_[0] |= 0x00000040u; +} +inline void AddressMapping::clear_has_ttl_s() { + _has_bits_[0] &= ~0x00000040u; +} +inline void AddressMapping::clear_ttl_s() { + ttl_s_ = 0u; + clear_has_ttl_s(); +} +inline ::google::protobuf::uint32 AddressMapping::ttl_s() const { + return ttl_s_; +} +inline void AddressMapping::set_ttl_s(::google::protobuf::uint32 value) { + set_has_ttl_s(); + ttl_s_ = value; +} + +// required string uri = 8; +inline bool AddressMapping::has_uri() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void AddressMapping::set_has_uri() { + _has_bits_[0] |= 0x00000080u; +} +inline void AddressMapping::clear_has_uri() { + _has_bits_[0] &= ~0x00000080u; +} +inline void AddressMapping::clear_uri() { + if (uri_ != &::google::protobuf::internal::kEmptyString) { + uri_->clear(); + } + clear_has_uri(); +} +inline const ::std::string& AddressMapping::uri() const { + return *uri_; +} +inline void AddressMapping::set_uri(const ::std::string& value) { + set_has_uri(); + if (uri_ == &::google::protobuf::internal::kEmptyString) { + uri_ = new ::std::string; + } + uri_->assign(value); +} +inline void AddressMapping::set_uri(const char* value) { + set_has_uri(); + if (uri_ == &::google::protobuf::internal::kEmptyString) { + uri_ = new ::std::string; + } + uri_->assign(value); +} +inline void AddressMapping::set_uri(const char* value, size_t size) { + set_has_uri(); + if (uri_ == &::google::protobuf::internal::kEmptyString) { + uri_ = new ::std::string; + } + uri_->assign(reinterpret_cast(value), size); +} +inline ::std::string* AddressMapping::mutable_uri() { + set_has_uri(); + if (uri_ == &::google::protobuf::internal::kEmptyString) { + uri_ = new ::std::string; + } + return uri_; +} +inline ::std::string* AddressMapping::release_uri() { + clear_has_uri(); + if (uri_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = uri_; + uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void AddressMapping::set_allocated_uri(::std::string* uri) { + if (uri_ != &::google::protobuf::internal::kEmptyString) { + delete uri_; + } + if (uri) { + set_has_uri(); + uri_ = uri; + } else { + clear_has_uri(); + uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// AddressMappingSet + +// repeated .xtreemfs.pbrpc.AddressMapping mappings = 1; +inline int AddressMappingSet::mappings_size() const { + return mappings_.size(); +} +inline void AddressMappingSet::clear_mappings() { + mappings_.Clear(); +} +inline const ::xtreemfs::pbrpc::AddressMapping& AddressMappingSet::mappings(int index) const { + return mappings_.Get(index); +} +inline ::xtreemfs::pbrpc::AddressMapping* AddressMappingSet::mutable_mappings(int index) { + return mappings_.Mutable(index); +} +inline ::xtreemfs::pbrpc::AddressMapping* AddressMappingSet::add_mappings() { + return mappings_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping >& +AddressMappingSet::mappings() const { + return mappings_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping >* +AddressMappingSet::mutable_mappings() { + return &mappings_; +} + +// ------------------------------------------------------------------- + +// DirService + +// required string address = 1; +inline bool DirService::has_address() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DirService::set_has_address() { + _has_bits_[0] |= 0x00000001u; +} +inline void DirService::clear_has_address() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DirService::clear_address() { + if (address_ != &::google::protobuf::internal::kEmptyString) { + address_->clear(); + } + clear_has_address(); +} +inline const ::std::string& DirService::address() const { + return *address_; +} +inline void DirService::set_address(const ::std::string& value) { + set_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + address_ = new ::std::string; + } + address_->assign(value); +} +inline void DirService::set_address(const char* value) { + set_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + address_ = new ::std::string; + } + address_->assign(value); +} +inline void DirService::set_address(const char* value, size_t size) { + set_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + address_ = new ::std::string; + } + address_->assign(reinterpret_cast(value), size); +} +inline ::std::string* DirService::mutable_address() { + set_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + address_ = new ::std::string; + } + return address_; +} +inline ::std::string* DirService::release_address() { + clear_has_address(); + if (address_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = address_; + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void DirService::set_allocated_address(::std::string* address) { + if (address_ != &::google::protobuf::internal::kEmptyString) { + delete address_; + } + if (address) { + set_has_address(); + address_ = address; + } else { + clear_has_address(); + address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 port = 2; +inline bool DirService::has_port() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void DirService::set_has_port() { + _has_bits_[0] |= 0x00000002u; +} +inline void DirService::clear_has_port() { + _has_bits_[0] &= ~0x00000002u; +} +inline void DirService::clear_port() { + port_ = 0u; + clear_has_port(); +} +inline ::google::protobuf::uint32 DirService::port() const { + return port_; +} +inline void DirService::set_port(::google::protobuf::uint32 value) { + set_has_port(); + port_ = value; +} + +// required string protocol = 3; +inline bool DirService::has_protocol() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void DirService::set_has_protocol() { + _has_bits_[0] |= 0x00000004u; +} +inline void DirService::clear_has_protocol() { + _has_bits_[0] &= ~0x00000004u; +} +inline void DirService::clear_protocol() { + if (protocol_ != &::google::protobuf::internal::kEmptyString) { + protocol_->clear(); + } + clear_has_protocol(); +} +inline const ::std::string& DirService::protocol() const { + return *protocol_; +} +inline void DirService::set_protocol(const ::std::string& value) { + set_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + protocol_ = new ::std::string; + } + protocol_->assign(value); +} +inline void DirService::set_protocol(const char* value) { + set_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + protocol_ = new ::std::string; + } + protocol_->assign(value); +} +inline void DirService::set_protocol(const char* value, size_t size) { + set_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + protocol_ = new ::std::string; + } + protocol_->assign(reinterpret_cast(value), size); +} +inline ::std::string* DirService::mutable_protocol() { + set_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + protocol_ = new ::std::string; + } + return protocol_; +} +inline ::std::string* DirService::release_protocol() { + clear_has_protocol(); + if (protocol_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = protocol_; + protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void DirService::set_allocated_protocol(::std::string* protocol) { + if (protocol_ != &::google::protobuf::internal::kEmptyString) { + delete protocol_; + } + if (protocol) { + set_has_protocol(); + protocol_ = protocol; + } else { + clear_has_protocol(); + protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 interface_version = 4; +inline bool DirService::has_interface_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void DirService::set_has_interface_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void DirService::clear_has_interface_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void DirService::clear_interface_version() { + interface_version_ = 0u; + clear_has_interface_version(); +} +inline ::google::protobuf::uint32 DirService::interface_version() const { + return interface_version_; +} +inline void DirService::set_interface_version(::google::protobuf::uint32 value) { + set_has_interface_version(); + interface_version_ = value; +} + +// ------------------------------------------------------------------- + +// ServiceDataMap + +// repeated .xtreemfs.pbrpc.KeyValuePair data = 1; +inline int ServiceDataMap::data_size() const { + return data_.size(); +} +inline void ServiceDataMap::clear_data() { + data_.Clear(); +} +inline const ::xtreemfs::pbrpc::KeyValuePair& ServiceDataMap::data(int index) const { + return data_.Get(index); +} +inline ::xtreemfs::pbrpc::KeyValuePair* ServiceDataMap::mutable_data(int index) { + return data_.Mutable(index); +} +inline ::xtreemfs::pbrpc::KeyValuePair* ServiceDataMap::add_data() { + return data_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >& +ServiceDataMap::data() const { + return data_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >* +ServiceDataMap::mutable_data() { + return &data_; +} + +// ------------------------------------------------------------------- + +// Service + +// required .xtreemfs.pbrpc.ServiceType type = 1; +inline bool Service::has_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Service::set_has_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void Service::clear_has_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Service::clear_type() { + type_ = 0; + clear_has_type(); +} +inline ::xtreemfs::pbrpc::ServiceType Service::type() const { + return static_cast< ::xtreemfs::pbrpc::ServiceType >(type_); +} +inline void Service::set_type(::xtreemfs::pbrpc::ServiceType value) { + assert(::xtreemfs::pbrpc::ServiceType_IsValid(value)); + set_has_type(); + type_ = value; +} + +// required string uuid = 2; +inline bool Service::has_uuid() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Service::set_has_uuid() { + _has_bits_[0] |= 0x00000002u; +} +inline void Service::clear_has_uuid() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Service::clear_uuid() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + clear_has_uuid(); +} +inline const ::std::string& Service::uuid() const { + return *uuid_; +} +inline void Service::set_uuid(const ::std::string& value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void Service::set_uuid(const char* value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void Service::set_uuid(const char* value, size_t size) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Service::mutable_uuid() { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + return uuid_; +} +inline ::std::string* Service::release_uuid() { + clear_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = uuid_; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Service::set_allocated_uuid(::std::string* uuid) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (uuid) { + set_has_uuid(); + uuid_ = uuid; + } else { + clear_has_uuid(); + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 version = 3; +inline bool Service::has_version() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Service::set_has_version() { + _has_bits_[0] |= 0x00000004u; +} +inline void Service::clear_has_version() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Service::clear_version() { + version_ = GOOGLE_ULONGLONG(0); + clear_has_version(); +} +inline ::google::protobuf::uint64 Service::version() const { + return version_; +} +inline void Service::set_version(::google::protobuf::uint64 value) { + set_has_version(); + version_ = value; +} + +// required string name = 4; +inline bool Service::has_name() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Service::set_has_name() { + _has_bits_[0] |= 0x00000008u; +} +inline void Service::clear_has_name() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Service::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& Service::name() const { + return *name_; +} +inline void Service::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void Service::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void Service::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Service::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* Service::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Service::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 last_updated_s = 5; +inline bool Service::has_last_updated_s() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Service::set_has_last_updated_s() { + _has_bits_[0] |= 0x00000010u; +} +inline void Service::clear_has_last_updated_s() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Service::clear_last_updated_s() { + last_updated_s_ = GOOGLE_ULONGLONG(0); + clear_has_last_updated_s(); +} +inline ::google::protobuf::uint64 Service::last_updated_s() const { + return last_updated_s_; +} +inline void Service::set_last_updated_s(::google::protobuf::uint64 value) { + set_has_last_updated_s(); + last_updated_s_ = value; +} + +// required .xtreemfs.pbrpc.ServiceDataMap data = 6; +inline bool Service::has_data() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Service::set_has_data() { + _has_bits_[0] |= 0x00000020u; +} +inline void Service::clear_has_data() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Service::clear_data() { + if (data_ != NULL) data_->::xtreemfs::pbrpc::ServiceDataMap::Clear(); + clear_has_data(); +} +inline const ::xtreemfs::pbrpc::ServiceDataMap& Service::data() const { + return data_ != NULL ? *data_ : *default_instance_->data_; +} +inline ::xtreemfs::pbrpc::ServiceDataMap* Service::mutable_data() { + set_has_data(); + if (data_ == NULL) data_ = new ::xtreemfs::pbrpc::ServiceDataMap; + return data_; +} +inline ::xtreemfs::pbrpc::ServiceDataMap* Service::release_data() { + clear_has_data(); + ::xtreemfs::pbrpc::ServiceDataMap* temp = data_; + data_ = NULL; + return temp; +} +inline void Service::set_allocated_data(::xtreemfs::pbrpc::ServiceDataMap* data) { + delete data_; + data_ = data; + if (data) { + set_has_data(); + } else { + clear_has_data(); + } +} + +// ------------------------------------------------------------------- + +// ServiceSet + +// repeated .xtreemfs.pbrpc.Service services = 1; +inline int ServiceSet::services_size() const { + return services_.size(); +} +inline void ServiceSet::clear_services() { + services_.Clear(); +} +inline const ::xtreemfs::pbrpc::Service& ServiceSet::services(int index) const { + return services_.Get(index); +} +inline ::xtreemfs::pbrpc::Service* ServiceSet::mutable_services(int index) { + return services_.Mutable(index); +} +inline ::xtreemfs::pbrpc::Service* ServiceSet::add_services() { + return services_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service >& +ServiceSet::services() const { + return services_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service >* +ServiceSet::mutable_services() { + return &services_; +} + +// ------------------------------------------------------------------- + +// Configuration + +// required string uuid = 1; +inline bool Configuration::has_uuid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Configuration::set_has_uuid() { + _has_bits_[0] |= 0x00000001u; +} +inline void Configuration::clear_has_uuid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Configuration::clear_uuid() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + clear_has_uuid(); +} +inline const ::std::string& Configuration::uuid() const { + return *uuid_; +} +inline void Configuration::set_uuid(const ::std::string& value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void Configuration::set_uuid(const char* value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void Configuration::set_uuid(const char* value, size_t size) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Configuration::mutable_uuid() { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + return uuid_; +} +inline ::std::string* Configuration::release_uuid() { + clear_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = uuid_; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Configuration::set_allocated_uuid(::std::string* uuid) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (uuid) { + set_has_uuid(); + uuid_ = uuid; + } else { + clear_has_uuid(); + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2; +inline int Configuration::parameter_size() const { + return parameter_.size(); +} +inline void Configuration::clear_parameter() { + parameter_.Clear(); +} +inline const ::xtreemfs::pbrpc::KeyValuePair& Configuration::parameter(int index) const { + return parameter_.Get(index); +} +inline ::xtreemfs::pbrpc::KeyValuePair* Configuration::mutable_parameter(int index) { + return parameter_.Mutable(index); +} +inline ::xtreemfs::pbrpc::KeyValuePair* Configuration::add_parameter() { + return parameter_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >& +Configuration::parameter() const { + return parameter_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >* +Configuration::mutable_parameter() { + return ¶meter_; +} + +// required fixed64 version = 3; +inline bool Configuration::has_version() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Configuration::set_has_version() { + _has_bits_[0] |= 0x00000004u; +} +inline void Configuration::clear_has_version() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Configuration::clear_version() { + version_ = GOOGLE_ULONGLONG(0); + clear_has_version(); +} +inline ::google::protobuf::uint64 Configuration::version() const { + return version_; +} +inline void Configuration::set_version(::google::protobuf::uint64 value) { + set_has_version(); + version_ = value; +} + +// ------------------------------------------------------------------- + +// addressMappingGetRequest + +// required string uuid = 1; +inline bool addressMappingGetRequest::has_uuid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void addressMappingGetRequest::set_has_uuid() { + _has_bits_[0] |= 0x00000001u; +} +inline void addressMappingGetRequest::clear_has_uuid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void addressMappingGetRequest::clear_uuid() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + clear_has_uuid(); +} +inline const ::std::string& addressMappingGetRequest::uuid() const { + return *uuid_; +} +inline void addressMappingGetRequest::set_uuid(const ::std::string& value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void addressMappingGetRequest::set_uuid(const char* value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void addressMappingGetRequest::set_uuid(const char* value, size_t size) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* addressMappingGetRequest::mutable_uuid() { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + return uuid_; +} +inline ::std::string* addressMappingGetRequest::release_uuid() { + clear_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = uuid_; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void addressMappingGetRequest::set_allocated_uuid(::std::string* uuid) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (uuid) { + set_has_uuid(); + uuid_ = uuid; + } else { + clear_has_uuid(); + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// addressMappingGetResponse + +// optional .xtreemfs.pbrpc.AddressMappingSet result = 1; +inline bool addressMappingGetResponse::has_result() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void addressMappingGetResponse::set_has_result() { + _has_bits_[0] |= 0x00000001u; +} +inline void addressMappingGetResponse::clear_has_result() { + _has_bits_[0] &= ~0x00000001u; +} +inline void addressMappingGetResponse::clear_result() { + if (result_ != NULL) result_->::xtreemfs::pbrpc::AddressMappingSet::Clear(); + clear_has_result(); +} +inline const ::xtreemfs::pbrpc::AddressMappingSet& addressMappingGetResponse::result() const { + return result_ != NULL ? *result_ : *default_instance_->result_; +} +inline ::xtreemfs::pbrpc::AddressMappingSet* addressMappingGetResponse::mutable_result() { + set_has_result(); + if (result_ == NULL) result_ = new ::xtreemfs::pbrpc::AddressMappingSet; + return result_; +} +inline ::xtreemfs::pbrpc::AddressMappingSet* addressMappingGetResponse::release_result() { + clear_has_result(); + ::xtreemfs::pbrpc::AddressMappingSet* temp = result_; + result_ = NULL; + return temp; +} +inline void addressMappingGetResponse::set_allocated_result(::xtreemfs::pbrpc::AddressMappingSet* result) { + delete result_; + result_ = result; + if (result) { + set_has_result(); + } else { + clear_has_result(); + } +} + +// ------------------------------------------------------------------- + +// addressMappingSetResponse + +// optional fixed64 new_version = 1; +inline bool addressMappingSetResponse::has_new_version() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void addressMappingSetResponse::set_has_new_version() { + _has_bits_[0] |= 0x00000001u; +} +inline void addressMappingSetResponse::clear_has_new_version() { + _has_bits_[0] &= ~0x00000001u; +} +inline void addressMappingSetResponse::clear_new_version() { + new_version_ = GOOGLE_ULONGLONG(0); + clear_has_new_version(); +} +inline ::google::protobuf::uint64 addressMappingSetResponse::new_version() const { + return new_version_; +} +inline void addressMappingSetResponse::set_new_version(::google::protobuf::uint64 value) { + set_has_new_version(); + new_version_ = value; +} + +// ------------------------------------------------------------------- + +// globalTimeSGetResponse + +// required fixed64 time_in_seconds = 1; +inline bool globalTimeSGetResponse::has_time_in_seconds() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void globalTimeSGetResponse::set_has_time_in_seconds() { + _has_bits_[0] |= 0x00000001u; +} +inline void globalTimeSGetResponse::clear_has_time_in_seconds() { + _has_bits_[0] &= ~0x00000001u; +} +inline void globalTimeSGetResponse::clear_time_in_seconds() { + time_in_seconds_ = GOOGLE_ULONGLONG(0); + clear_has_time_in_seconds(); +} +inline ::google::protobuf::uint64 globalTimeSGetResponse::time_in_seconds() const { + return time_in_seconds_; +} +inline void globalTimeSGetResponse::set_time_in_seconds(::google::protobuf::uint64 value) { + set_has_time_in_seconds(); + time_in_seconds_ = value; +} + +// ------------------------------------------------------------------- + +// serviceDeregisterRequest + +// required string uuid = 1; +inline bool serviceDeregisterRequest::has_uuid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void serviceDeregisterRequest::set_has_uuid() { + _has_bits_[0] |= 0x00000001u; +} +inline void serviceDeregisterRequest::clear_has_uuid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void serviceDeregisterRequest::clear_uuid() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + clear_has_uuid(); +} +inline const ::std::string& serviceDeregisterRequest::uuid() const { + return *uuid_; +} +inline void serviceDeregisterRequest::set_uuid(const ::std::string& value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void serviceDeregisterRequest::set_uuid(const char* value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void serviceDeregisterRequest::set_uuid(const char* value, size_t size) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* serviceDeregisterRequest::mutable_uuid() { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + return uuid_; +} +inline ::std::string* serviceDeregisterRequest::release_uuid() { + clear_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = uuid_; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void serviceDeregisterRequest::set_allocated_uuid(::std::string* uuid) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (uuid) { + set_has_uuid(); + uuid_ = uuid; + } else { + clear_has_uuid(); + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// serviceGetByNameRequest + +// required string name = 1; +inline bool serviceGetByNameRequest::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void serviceGetByNameRequest::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void serviceGetByNameRequest::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void serviceGetByNameRequest::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& serviceGetByNameRequest::name() const { + return *name_; +} +inline void serviceGetByNameRequest::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void serviceGetByNameRequest::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void serviceGetByNameRequest::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* serviceGetByNameRequest::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* serviceGetByNameRequest::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void serviceGetByNameRequest::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// serviceGetByUUIDRequest + +// required string name = 1; +inline bool serviceGetByUUIDRequest::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void serviceGetByUUIDRequest::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void serviceGetByUUIDRequest::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void serviceGetByUUIDRequest::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& serviceGetByUUIDRequest::name() const { + return *name_; +} +inline void serviceGetByUUIDRequest::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void serviceGetByUUIDRequest::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void serviceGetByUUIDRequest::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* serviceGetByUUIDRequest::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* serviceGetByUUIDRequest::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void serviceGetByUUIDRequest::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// serviceGetByTypeRequest + +// required .xtreemfs.pbrpc.ServiceType type = 1; +inline bool serviceGetByTypeRequest::has_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void serviceGetByTypeRequest::set_has_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void serviceGetByTypeRequest::clear_has_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void serviceGetByTypeRequest::clear_type() { + type_ = 0; + clear_has_type(); +} +inline ::xtreemfs::pbrpc::ServiceType serviceGetByTypeRequest::type() const { + return static_cast< ::xtreemfs::pbrpc::ServiceType >(type_); +} +inline void serviceGetByTypeRequest::set_type(::xtreemfs::pbrpc::ServiceType value) { + assert(::xtreemfs::pbrpc::ServiceType_IsValid(value)); + set_has_type(); + type_ = value; +} + +// ------------------------------------------------------------------- + +// serviceRegisterRequest + +// required .xtreemfs.pbrpc.Service service = 1; +inline bool serviceRegisterRequest::has_service() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void serviceRegisterRequest::set_has_service() { + _has_bits_[0] |= 0x00000001u; +} +inline void serviceRegisterRequest::clear_has_service() { + _has_bits_[0] &= ~0x00000001u; +} +inline void serviceRegisterRequest::clear_service() { + if (service_ != NULL) service_->::xtreemfs::pbrpc::Service::Clear(); + clear_has_service(); +} +inline const ::xtreemfs::pbrpc::Service& serviceRegisterRequest::service() const { + return service_ != NULL ? *service_ : *default_instance_->service_; +} +inline ::xtreemfs::pbrpc::Service* serviceRegisterRequest::mutable_service() { + set_has_service(); + if (service_ == NULL) service_ = new ::xtreemfs::pbrpc::Service; + return service_; +} +inline ::xtreemfs::pbrpc::Service* serviceRegisterRequest::release_service() { + clear_has_service(); + ::xtreemfs::pbrpc::Service* temp = service_; + service_ = NULL; + return temp; +} +inline void serviceRegisterRequest::set_allocated_service(::xtreemfs::pbrpc::Service* service) { + delete service_; + service_ = service; + if (service) { + set_has_service(); + } else { + clear_has_service(); + } +} + +// ------------------------------------------------------------------- + +// serviceRegisterResponse + +// required fixed64 new_version = 1; +inline bool serviceRegisterResponse::has_new_version() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void serviceRegisterResponse::set_has_new_version() { + _has_bits_[0] |= 0x00000001u; +} +inline void serviceRegisterResponse::clear_has_new_version() { + _has_bits_[0] &= ~0x00000001u; +} +inline void serviceRegisterResponse::clear_new_version() { + new_version_ = GOOGLE_ULONGLONG(0); + clear_has_new_version(); +} +inline ::google::protobuf::uint64 serviceRegisterResponse::new_version() const { + return new_version_; +} +inline void serviceRegisterResponse::set_new_version(::google::protobuf::uint64 value) { + set_has_new_version(); + new_version_ = value; +} + +// ------------------------------------------------------------------- + +// configurationGetRequest + +// required string uuid = 1; +inline bool configurationGetRequest::has_uuid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void configurationGetRequest::set_has_uuid() { + _has_bits_[0] |= 0x00000001u; +} +inline void configurationGetRequest::clear_has_uuid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void configurationGetRequest::clear_uuid() { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + uuid_->clear(); + } + clear_has_uuid(); +} +inline const ::std::string& configurationGetRequest::uuid() const { + return *uuid_; +} +inline void configurationGetRequest::set_uuid(const ::std::string& value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void configurationGetRequest::set_uuid(const char* value) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(value); +} +inline void configurationGetRequest::set_uuid(const char* value, size_t size) { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* configurationGetRequest::mutable_uuid() { + set_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + uuid_ = new ::std::string; + } + return uuid_; +} +inline ::std::string* configurationGetRequest::release_uuid() { + clear_has_uuid(); + if (uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = uuid_; + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void configurationGetRequest::set_allocated_uuid(::std::string* uuid) { + if (uuid_ != &::google::protobuf::internal::kEmptyString) { + delete uuid_; + } + if (uuid) { + set_has_uuid(); + uuid_ = uuid; + } else { + clear_has_uuid(); + uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// configurationSetResponse + +// optional fixed64 new_version = 1; +inline bool configurationSetResponse::has_new_version() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void configurationSetResponse::set_has_new_version() { + _has_bits_[0] |= 0x00000001u; +} +inline void configurationSetResponse::clear_has_new_version() { + _has_bits_[0] &= ~0x00000001u; +} +inline void configurationSetResponse::clear_new_version() { + new_version_ = GOOGLE_ULONGLONG(0); + clear_has_new_version(); +} +inline ::google::protobuf::uint64 configurationSetResponse::new_version() const { + return new_version_; +} +inline void configurationSetResponse::set_new_version(::google::protobuf::uint64 value) { + set_has_new_version(); + new_version_ = value; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::ServiceType>() { + return ::xtreemfs::pbrpc::ServiceType_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::ServiceStatus>() { + return ::xtreemfs::pbrpc::ServiceStatus_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_xtreemfs_2fDIR_2eproto__INCLUDED diff --git a/cpp/generated/xtreemfs/DIRServiceClient.h b/cpp/generated/xtreemfs/DIRServiceClient.h new file mode 100644 index 0000000..25f5878 --- /dev/null +++ b/cpp/generated/xtreemfs/DIRServiceClient.h @@ -0,0 +1,405 @@ +//automatically generated from DIR.proto at Thu Dec 11 16:09:40 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef DIRSERVICECLIENT_H +#define DIRSERVICECLIENT_H + +#include +#include "pbrpc/RPC.pb.h" +#include "rpc/client.h" +#include "rpc/sync_callback.h" +#include "rpc/callback_interface.h" +#include "include/Common.pb.h" +#include "xtreemfs/GlobalTypes.pb.h" +#include "xtreemfs/DIR.pb.h" + + +namespace xtreemfs { +namespace pbrpc { + using ::xtreemfs::rpc::Client; + using ::xtreemfs::rpc::CallbackInterface; + using ::xtreemfs::rpc::SyncCallback; + + class DIRServiceClient { + + public: + DIRServiceClient(Client* client) : client_(client) { + } + + virtual ~DIRServiceClient() { + } + + void xtreemfs_address_mappings_get(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::addressMappingGetRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 1, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::AddressMappingSet(), + context, callback); + } + + SyncCallback* xtreemfs_address_mappings_get_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::addressMappingGetRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 1, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::AddressMappingSet(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_address_mappings_remove(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::addressMappingGetRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 2, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_address_mappings_remove_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::addressMappingGetRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 2, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_address_mappings_set(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::AddressMappingSet* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 3, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::addressMappingSetResponse(), + context, callback); + } + + SyncCallback* xtreemfs_address_mappings_set_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::AddressMappingSet* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 3, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::addressMappingSetResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_discover_dir(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 10001, 4, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::DirService(), + context, callback); + } + + SyncCallback* xtreemfs_discover_dir_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 4, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::DirService(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_global_time_s_get(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 10001, 5, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::globalTimeSGetResponse(), + context, callback); + } + + SyncCallback* xtreemfs_global_time_s_get_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 5, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::globalTimeSGetResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_service_deregister(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::serviceDeregisterRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 6, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_service_deregister_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::serviceDeregisterRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 6, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_service_get_by_name(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::serviceGetByNameRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 7, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(), + context, callback); + } + + SyncCallback* xtreemfs_service_get_by_name_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::serviceGetByNameRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 7, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_service_get_by_type(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::serviceGetByTypeRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 8, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(), + context, callback); + } + + SyncCallback* xtreemfs_service_get_by_type_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::serviceGetByTypeRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 8, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_service_get_by_uuid(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::serviceGetByUUIDRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 9, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(), + context, callback); + } + + SyncCallback* xtreemfs_service_get_by_uuid_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::serviceGetByUUIDRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 9, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_service_offline(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::serviceGetByUUIDRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 10, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_service_offline_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::serviceGetByUUIDRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 10, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_service_register(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::serviceRegisterRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 11, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::serviceRegisterResponse(), + context, callback); + } + + SyncCallback* xtreemfs_service_register_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::serviceRegisterRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 11, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::serviceRegisterResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_checkpoint(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 10001, 20, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_checkpoint_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 20, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_shutdown(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 10001, 21, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_shutdown_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 21, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_configuration_get(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::configurationGetRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 22, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Configuration(), + context, callback); + } + + SyncCallback* xtreemfs_configuration_get_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::configurationGetRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 22, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Configuration(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_configuration_set(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::Configuration* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 23, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::configurationSetResponse(), + context, callback); + } + + SyncCallback* xtreemfs_configuration_set_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::Configuration* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 23, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::configurationSetResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_vivaldi_client_update(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::VivaldiCoordinates* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 10001, 24, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_vivaldi_client_update_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::VivaldiCoordinates* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 10001, 24, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + private: + Client* client_; + }; + } +} +#endif //DIRSERVICECLIENT_H diff --git a/cpp/generated/xtreemfs/DIRServiceConstants.h b/cpp/generated/xtreemfs/DIRServiceConstants.h new file mode 100644 index 0000000..6446ed0 --- /dev/null +++ b/cpp/generated/xtreemfs/DIRServiceConstants.h @@ -0,0 +1,32 @@ +//automatically generated from DIR.proto at Thu Dec 11 16:09:40 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef DIRSERVICECONSTANTS_H_ +#define DIRSERVICECONSTANTS_H_ +#include + +namespace xtreemfs { +namespace pbrpc { + +const uint32_t INTERFACE_ID_DIR = 10001; +const uint32_t PROC_ID_XTREEMFS_ADDRESS_MAPPINGS_GET = 1; +const uint32_t PROC_ID_XTREEMFS_ADDRESS_MAPPINGS_REMOVE = 2; +const uint32_t PROC_ID_XTREEMFS_ADDRESS_MAPPINGS_SET = 3; +const uint32_t PROC_ID_XTREEMFS_DISCOVER_DIR = 4; +const uint32_t PROC_ID_XTREEMFS_GLOBAL_TIME_S_GET = 5; +const uint32_t PROC_ID_XTREEMFS_SERVICE_DEREGISTER = 6; +const uint32_t PROC_ID_XTREEMFS_SERVICE_GET_BY_NAME = 7; +const uint32_t PROC_ID_XTREEMFS_SERVICE_GET_BY_TYPE = 8; +const uint32_t PROC_ID_XTREEMFS_SERVICE_GET_BY_UUID = 9; +const uint32_t PROC_ID_XTREEMFS_SERVICE_OFFLINE = 10; +const uint32_t PROC_ID_XTREEMFS_SERVICE_REGISTER = 11; +const uint32_t PROC_ID_XTREEMFS_CHECKPOINT = 20; +const uint32_t PROC_ID_XTREEMFS_SHUTDOWN = 21; +const uint32_t PROC_ID_XTREEMFS_CONFIGURATION_GET = 22; +const uint32_t PROC_ID_XTREEMFS_CONFIGURATION_SET = 23; +const uint32_t PROC_ID_XTREEMFS_VIVALDI_CLIENT_UPDATE = 24; + +} // namespace pbrpc +} // namespace xtreemfs + +#endif // DIRSERVICECLIENT_H_ diff --git a/cpp/generated/xtreemfs/GlobalTypes.pb.cc b/cpp/generated/xtreemfs/GlobalTypes.pb.cc new file mode 100644 index 0000000..cc96212 --- /dev/null +++ b/cpp/generated/xtreemfs/GlobalTypes.pb.cc @@ -0,0 +1,3991 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: xtreemfs/GlobalTypes.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "xtreemfs/GlobalTypes.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +namespace { + +const ::google::protobuf::Descriptor* NewFileSize_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + NewFileSize_reflection_ = NULL; +const ::google::protobuf::Descriptor* StripingPolicy_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + StripingPolicy_reflection_ = NULL; +const ::google::protobuf::Descriptor* Replica_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Replica_reflection_ = NULL; +const ::google::protobuf::Descriptor* Replicas_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Replicas_reflection_ = NULL; +const ::google::protobuf::Descriptor* XCap_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + XCap_reflection_ = NULL; +const ::google::protobuf::Descriptor* XLocSet_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + XLocSet_reflection_ = NULL; +const ::google::protobuf::Descriptor* FileCredentials_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FileCredentials_reflection_ = NULL; +const ::google::protobuf::Descriptor* FileCredentialsSet_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + FileCredentialsSet_reflection_ = NULL; +const ::google::protobuf::Descriptor* VivaldiCoordinates_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + VivaldiCoordinates_reflection_ = NULL; +const ::google::protobuf::Descriptor* OSDWriteResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + OSDWriteResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* KeyValuePair_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + KeyValuePair_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* AccessControlPolicyType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* OSDSelectionPolicyType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* ReplicaSelectionPolicyType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* SnapConfig_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* StripingPolicyType_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* LeaseState_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* PORTS_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* CONSTANTS_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* SYSTEM_V_FCNTL_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* REPL_FLAG_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* SERVICES_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto() { + protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "xtreemfs/GlobalTypes.proto"); + GOOGLE_CHECK(file != NULL); + NewFileSize_descriptor_ = file->message_type(0); + static const int NewFileSize_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NewFileSize, size_in_bytes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NewFileSize, truncate_epoch_), + }; + NewFileSize_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + NewFileSize_descriptor_, + NewFileSize::default_instance_, + NewFileSize_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NewFileSize, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NewFileSize, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(NewFileSize)); + StripingPolicy_descriptor_ = file->message_type(1); + static const int StripingPolicy_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StripingPolicy, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StripingPolicy, stripe_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StripingPolicy, width_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StripingPolicy, parity_width_), + }; + StripingPolicy_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + StripingPolicy_descriptor_, + StripingPolicy::default_instance_, + StripingPolicy_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StripingPolicy, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StripingPolicy, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(StripingPolicy)); + Replica_descriptor_ = file->message_type(2); + static const int Replica_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Replica, osd_uuids_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Replica, replication_flags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Replica, striping_policy_), + }; + Replica_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Replica_descriptor_, + Replica::default_instance_, + Replica_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Replica, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Replica, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Replica)); + Replicas_descriptor_ = file->message_type(3); + static const int Replicas_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Replicas, replicas_), + }; + Replicas_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Replicas_descriptor_, + Replicas::default_instance_, + Replicas_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Replicas, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Replicas, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Replicas)); + XCap_descriptor_ = file->message_type(4); + static const int XCap_offsets_[10] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, access_mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, client_identity_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, expire_time_s_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, expire_timeout_s_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, replicate_on_close_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, server_signature_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, truncate_epoch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, snap_config_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, snap_timestamp_), + }; + XCap_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + XCap_descriptor_, + XCap::default_instance_, + XCap_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XCap, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(XCap)); + XLocSet_descriptor_ = file->message_type(5); + static const int XLocSet_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSet, read_only_file_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSet, replicas_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSet, replica_update_policy_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSet, version_), + }; + XLocSet_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + XLocSet_descriptor_, + XLocSet::default_instance_, + XLocSet_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSet, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSet, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(XLocSet)); + FileCredentials_descriptor_ = file->message_type(6); + static const int FileCredentials_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileCredentials, xcap_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileCredentials, xlocs_), + }; + FileCredentials_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + FileCredentials_descriptor_, + FileCredentials::default_instance_, + FileCredentials_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileCredentials, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileCredentials, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(FileCredentials)); + FileCredentialsSet_descriptor_ = file->message_type(7); + static const int FileCredentialsSet_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileCredentialsSet, file_credentials_), + }; + FileCredentialsSet_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + FileCredentialsSet_descriptor_, + FileCredentialsSet::default_instance_, + FileCredentialsSet_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileCredentialsSet, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileCredentialsSet, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(FileCredentialsSet)); + VivaldiCoordinates_descriptor_ = file->message_type(8); + static const int VivaldiCoordinates_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VivaldiCoordinates, x_coordinate_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VivaldiCoordinates, y_coordinate_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VivaldiCoordinates, local_error_), + }; + VivaldiCoordinates_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + VivaldiCoordinates_descriptor_, + VivaldiCoordinates::default_instance_, + VivaldiCoordinates_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VivaldiCoordinates, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VivaldiCoordinates, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(VivaldiCoordinates)); + OSDWriteResponse_descriptor_ = file->message_type(9); + static const int OSDWriteResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OSDWriteResponse, size_in_bytes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OSDWriteResponse, truncate_epoch_), + }; + OSDWriteResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + OSDWriteResponse_descriptor_, + OSDWriteResponse::default_instance_, + OSDWriteResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OSDWriteResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OSDWriteResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(OSDWriteResponse)); + KeyValuePair_descriptor_ = file->message_type(10); + static const int KeyValuePair_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KeyValuePair, key_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KeyValuePair, value_), + }; + KeyValuePair_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + KeyValuePair_descriptor_, + KeyValuePair::default_instance_, + KeyValuePair_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KeyValuePair, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KeyValuePair, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(KeyValuePair)); + AccessControlPolicyType_descriptor_ = file->enum_type(0); + OSDSelectionPolicyType_descriptor_ = file->enum_type(1); + ReplicaSelectionPolicyType_descriptor_ = file->enum_type(2); + SnapConfig_descriptor_ = file->enum_type(3); + StripingPolicyType_descriptor_ = file->enum_type(4); + LeaseState_descriptor_ = file->enum_type(5); + PORTS_descriptor_ = file->enum_type(6); + CONSTANTS_descriptor_ = file->enum_type(7); + SYSTEM_V_FCNTL_descriptor_ = file->enum_type(8); + REPL_FLAG_descriptor_ = file->enum_type(9); + SERVICES_descriptor_ = file->enum_type(10); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + NewFileSize_descriptor_, &NewFileSize::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + StripingPolicy_descriptor_, &StripingPolicy::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Replica_descriptor_, &Replica::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Replicas_descriptor_, &Replicas::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + XCap_descriptor_, &XCap::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + XLocSet_descriptor_, &XLocSet::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FileCredentials_descriptor_, &FileCredentials::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + FileCredentialsSet_descriptor_, &FileCredentialsSet::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + VivaldiCoordinates_descriptor_, &VivaldiCoordinates::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + OSDWriteResponse_descriptor_, &OSDWriteResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + KeyValuePair_descriptor_, &KeyValuePair::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto() { + delete NewFileSize::default_instance_; + delete NewFileSize_reflection_; + delete StripingPolicy::default_instance_; + delete StripingPolicy_reflection_; + delete Replica::default_instance_; + delete Replica_reflection_; + delete Replicas::default_instance_; + delete Replicas_reflection_; + delete XCap::default_instance_; + delete XCap_reflection_; + delete XLocSet::default_instance_; + delete XLocSet_reflection_; + delete FileCredentials::default_instance_; + delete FileCredentials_reflection_; + delete FileCredentialsSet::default_instance_; + delete FileCredentialsSet_reflection_; + delete VivaldiCoordinates::default_instance_; + delete VivaldiCoordinates_reflection_; + delete OSDWriteResponse::default_instance_; + delete OSDWriteResponse_reflection_; + delete KeyValuePair::default_instance_; + delete KeyValuePair_reflection_; +} + +void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fPBRPC_2eproto(); + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fCommon_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\032xtreemfs/GlobalTypes.proto\022\016xtreemfs.p" + "brpc\032\023include/PBRPC.proto\032\024include/Commo" + "n.proto\"<\n\013NewFileSize\022\025\n\rsize_in_bytes\030" + "\001 \002(\006\022\026\n\016truncate_epoch\030\002 \002(\007\"|\n\016Stripin" + "gPolicy\0220\n\004type\030\001 \002(\0162\".xtreemfs.pbrpc.S" + "tripingPolicyType\022\023\n\013stripe_size\030\002 \002(\007\022\r" + "\n\005width\030\003 \002(\007\022\024\n\014parity_width\030\004 \001(\007\"p\n\007R" + "eplica\022\021\n\tosd_uuids\030\001 \003(\t\022\031\n\021replication" + "_flags\030\002 \002(\007\0227\n\017striping_policy\030\003 \002(\0132\036." + "xtreemfs.pbrpc.StripingPolicy\"5\n\010Replica" + "s\022)\n\010replicas\030\001 \003(\0132\027.xtreemfs.pbrpc.Rep" + "lica\"\215\002\n\004XCap\022\023\n\013access_mode\030\001 \002(\007\022\027\n\017cl" + "ient_identity\030\002 \002(\t\022\025\n\rexpire_time_s\030\003 \002" + "(\006\022\030\n\020expire_timeout_s\030\004 \002(\007\022\017\n\007file_id\030" + "\005 \002(\t\022\032\n\022replicate_on_close\030\006 \002(\010\022\030\n\020ser" + "ver_signature\030\007 \002(\t\022\026\n\016truncate_epoch\030\010 " + "\002(\007\022/\n\013snap_config\030\t \002(\0162\032.xtreemfs.pbrp" + "c.SnapConfig\022\026\n\016snap_timestamp\030\n \002(\006\"\201\001\n" + "\007XLocSet\022\033\n\023read_only_file_size\030\001 \002(\006\022)\n" + "\010replicas\030\002 \003(\0132\027.xtreemfs.pbrpc.Replica" + "\022\035\n\025replica_update_policy\030\003 \002(\t\022\017\n\007versi" + "on\030\004 \002(\007\"]\n\017FileCredentials\022\"\n\004xcap\030\001 \002(" + "\0132\024.xtreemfs.pbrpc.XCap\022&\n\005xlocs\030\002 \002(\0132\027" + ".xtreemfs.pbrpc.XLocSet\"O\n\022FileCredentia" + "lsSet\0229\n\020file_credentials\030\001 \001(\0132\037.xtreem" + "fs.pbrpc.FileCredentials\"U\n\022VivaldiCoord" + "inates\022\024\n\014x_coordinate\030\001 \002(\001\022\024\n\014y_coordi" + "nate\030\002 \002(\001\022\023\n\013local_error\030\003 \002(\001\"A\n\020OSDWr" + "iteResponse\022\025\n\rsize_in_bytes\030\001 \001(\006\022\026\n\016tr" + "uncate_epoch\030\002 \001(\007\"*\n\014KeyValuePair\022\013\n\003ke" + "y\030\001 \002(\t\022\r\n\005value\030\002 \002(\t*|\n\027AccessControlP" + "olicyType\022\036\n\032ACCESS_CONTROL_POLICY_NULL\020" + "\001\022\037\n\033ACCESS_CONTROL_POLICY_POSIX\020\002\022 \n\034AC" + "CESS_CONTROL_POLICY_VOLUME\020\003*\365\003\n\026OSDSele" + "ctionPolicyType\022(\n#OSD_SELECTION_POLICY_" + "FILTER_DEFAULT\020\350\007\022%\n OSD_SELECTION_POLIC" + "Y_FILTER_FQDN\020\351\007\022%\n OSD_SELECTION_POLICY" + "_FILTER_UUID\020\352\007\022%\n OSD_SELECTION_POLICY_" + "GROUP_DCMAP\020\320\017\022$\n\037OSD_SELECTION_POLICY_G" + "ROUP_FQDN\020\321\017\022$\n\037OSD_SELECTION_POLICY_SOR" + "T_DCMAP\020\270\027\022#\n\036OSD_SELECTION_POLICY_SORT_" + "FQDN\020\271\027\022%\n OSD_SELECTION_POLICY_SORT_RAN" + "DOM\020\272\027\022&\n!OSD_SELECTION_POLICY_SORT_VIVA" + "LDI\020\273\027\022/\n*OSD_SELECTION_POLICY_SORT_HOST" + "_ROUND_ROBIN\020\274\027\022#\n\036OSD_SELECTION_POLICY_" + "SORT_UUID\020\236\037\022&\n!OSD_SELECTION_POLICY_SOR" + "T_REVERSE\020\237\037*A\n\032ReplicaSelectionPolicyTy" + "pe\022#\n\037REPLICA_SELECTION_POLICY_SIMPLE\020\001*" + "i\n\nSnapConfig\022\036\n\032SNAP_CONFIG_SNAPS_DISAB" + "LED\020\000\022\036\n\032SNAP_CONFIG_ACCESS_CURRENT\020\001\022\033\n" + "\027SNAP_CONFIG_ACCESS_SNAP\020\002*P\n\022StripingPo" + "licyType\022\031\n\025STRIPING_POLICY_RAID0\020\000\022\037\n\033S" + "TRIPING_POLICY_ERASURECODE\020\001*9\n\nLeaseSta" + "te\022\010\n\004NONE\020\000\022\013\n\007PRIMARY\020\001\022\n\n\006BACKUP\020\002\022\010\n" + "\004IDLE\020\003*\270\001\n\005PORTS\022\033\n\025DIR_HTTP_PORT_DEFAU" + "LT\020\256\357\001\022\034\n\026DIR_PBRPC_PORT_DEFAULT\020\376\376\001\022\033\n\025" + "MRC_HTTP_PORT_DEFAULT\020\254\357\001\022\034\n\026MRC_PBRPC_P" + "ORT_DEFAULT\020\374\376\001\022\033\n\025OSD_HTTP_PORT_DEFAULT" + "\020\260\357\001\022\034\n\026OSD_PBRPC_PORT_DEFAULT\020\200\377\001*+\n\tCO" + "NSTANTS\022\036\n\032XCAP_RENEW_INTERVAL_IN_MIN\020\001*" + "\202\003\n\016SYSTEM_V_FCNTL\022\035\n\031SYSTEM_V_FCNTL_H_O" + "_RDONLY\020\000\022\035\n\031SYSTEM_V_FCNTL_H_O_WRONLY\020\001" + "\022\033\n\027SYSTEM_V_FCNTL_H_O_RDWR\020\002\022\035\n\031SYSTEM_" + "V_FCNTL_H_O_APPEND\020\010\022\035\n\030SYSTEM_V_FCNTL_H" + "_O_CREAT\020\200\002\022\035\n\030SYSTEM_V_FCNTL_H_O_TRUNC\020" + "\200\004\022\034\n\027SYSTEM_V_FCNTL_H_O_EXCL\020\200\010\022\033\n\027SYST" + "EM_V_FCNTL_H_O_SYNC\020\020\022\036\n\030SYSTEM_V_FCNTL_" + "H_S_IFREG\020\200\200\002\022\036\n\030SYSTEM_V_FCNTL_H_S_IFDI" + "R\020\200\200\001\022\036\n\030SYSTEM_V_FCNTL_H_S_IFLNK\020\200\300\002\022\035\n" + "\030SYSTEM_V_FCNTL_H_S_IFIFO\020\200 *\330\001\n\tREPL_FL" + "AG\022\032\n\026REPL_FLAG_FULL_REPLICA\020\001\022\031\n\025REPL_F" + "LAG_IS_COMPLETE\020\002\022\035\n\031REPL_FLAG_STRATEGY_" + "RANDOM\020\004\022#\n\037REPL_FLAG_STRATEGY_RAREST_FI" + "RST\020\010\022!\n\035REPL_FLAG_STRATEGY_SEQUENTIAL\020\020" + "\022-\n)REPL_FLAG_STRATEGY_SEQUENTIAL_PREFET" + "CHING\020 *%\n\010SERVICES\022\007\n\003DIR\020\001\022\007\n\003MRC\020\002\022\007\n" + "\003OSD\020\003B(\n&org.xtreemfs.pbrpc.generatedin" + "terfaces", 3088); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "xtreemfs/GlobalTypes.proto", &protobuf_RegisterTypes); + NewFileSize::default_instance_ = new NewFileSize(); + StripingPolicy::default_instance_ = new StripingPolicy(); + Replica::default_instance_ = new Replica(); + Replicas::default_instance_ = new Replicas(); + XCap::default_instance_ = new XCap(); + XLocSet::default_instance_ = new XLocSet(); + FileCredentials::default_instance_ = new FileCredentials(); + FileCredentialsSet::default_instance_ = new FileCredentialsSet(); + VivaldiCoordinates::default_instance_ = new VivaldiCoordinates(); + OSDWriteResponse::default_instance_ = new OSDWriteResponse(); + KeyValuePair::default_instance_ = new KeyValuePair(); + NewFileSize::default_instance_->InitAsDefaultInstance(); + StripingPolicy::default_instance_->InitAsDefaultInstance(); + Replica::default_instance_->InitAsDefaultInstance(); + Replicas::default_instance_->InitAsDefaultInstance(); + XCap::default_instance_->InitAsDefaultInstance(); + XLocSet::default_instance_->InitAsDefaultInstance(); + FileCredentials::default_instance_->InitAsDefaultInstance(); + FileCredentialsSet::default_instance_->InitAsDefaultInstance(); + VivaldiCoordinates::default_instance_->InitAsDefaultInstance(); + OSDWriteResponse::default_instance_->InitAsDefaultInstance(); + KeyValuePair::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_xtreemfs_2fGlobalTypes_2eproto { + StaticDescriptorInitializer_xtreemfs_2fGlobalTypes_2eproto() { + protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + } +} static_descriptor_initializer_xtreemfs_2fGlobalTypes_2eproto_; +const ::google::protobuf::EnumDescriptor* AccessControlPolicyType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return AccessControlPolicyType_descriptor_; +} +bool AccessControlPolicyType_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* OSDSelectionPolicyType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return OSDSelectionPolicyType_descriptor_; +} +bool OSDSelectionPolicyType_IsValid(int value) { + switch(value) { + case 1000: + case 1001: + case 1002: + case 2000: + case 2001: + case 3000: + case 3001: + case 3002: + case 3003: + case 3004: + case 3998: + case 3999: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* ReplicaSelectionPolicyType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ReplicaSelectionPolicyType_descriptor_; +} +bool ReplicaSelectionPolicyType_IsValid(int value) { + switch(value) { + case 1: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* SnapConfig_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SnapConfig_descriptor_; +} +bool SnapConfig_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* StripingPolicyType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return StripingPolicyType_descriptor_; +} +bool StripingPolicyType_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* LeaseState_descriptor() { + protobuf_AssignDescriptorsOnce(); + return LeaseState_descriptor_; +} +bool LeaseState_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* PORTS_descriptor() { + protobuf_AssignDescriptorsOnce(); + return PORTS_descriptor_; +} +bool PORTS_IsValid(int value) { + switch(value) { + case 30636: + case 30638: + case 30640: + case 32636: + case 32638: + case 32640: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* CONSTANTS_descriptor() { + protobuf_AssignDescriptorsOnce(); + return CONSTANTS_descriptor_; +} +bool CONSTANTS_IsValid(int value) { + switch(value) { + case 1: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* SYSTEM_V_FCNTL_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SYSTEM_V_FCNTL_descriptor_; +} +bool SYSTEM_V_FCNTL_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 8: + case 16: + case 256: + case 512: + case 1024: + case 4096: + case 16384: + case 32768: + case 40960: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* REPL_FLAG_descriptor() { + protobuf_AssignDescriptorsOnce(); + return REPL_FLAG_descriptor_; +} +bool REPL_FLAG_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 4: + case 8: + case 16: + case 32: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* SERVICES_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SERVICES_descriptor_; +} +bool SERVICES_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + + +// =================================================================== + +#ifndef _MSC_VER +const int NewFileSize::kSizeInBytesFieldNumber; +const int NewFileSize::kTruncateEpochFieldNumber; +#endif // !_MSC_VER + +NewFileSize::NewFileSize() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void NewFileSize::InitAsDefaultInstance() { +} + +NewFileSize::NewFileSize(const NewFileSize& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void NewFileSize::SharedCtor() { + _cached_size_ = 0; + size_in_bytes_ = GOOGLE_ULONGLONG(0); + truncate_epoch_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +NewFileSize::~NewFileSize() { + SharedDtor(); +} + +void NewFileSize::SharedDtor() { + if (this != default_instance_) { + } +} + +void NewFileSize::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NewFileSize::descriptor() { + protobuf_AssignDescriptorsOnce(); + return NewFileSize_descriptor_; +} + +const NewFileSize& NewFileSize::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +NewFileSize* NewFileSize::default_instance_ = NULL; + +NewFileSize* NewFileSize::New() const { + return new NewFileSize; +} + +void NewFileSize::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_in_bytes_ = GOOGLE_ULONGLONG(0); + truncate_epoch_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool NewFileSize::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 size_in_bytes = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &size_in_bytes_))); + set_has_size_in_bytes(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_truncate_epoch; + break; + } + + // required fixed32 truncate_epoch = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_truncate_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &truncate_epoch_))); + set_has_truncate_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void NewFileSize::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 size_in_bytes = 1; + if (has_size_in_bytes()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->size_in_bytes(), output); + } + + // required fixed32 truncate_epoch = 2; + if (has_truncate_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->truncate_epoch(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* NewFileSize::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 size_in_bytes = 1; + if (has_size_in_bytes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->size_in_bytes(), target); + } + + // required fixed32 truncate_epoch = 2; + if (has_truncate_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->truncate_epoch(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int NewFileSize::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 size_in_bytes = 1; + if (has_size_in_bytes()) { + total_size += 1 + 8; + } + + // required fixed32 truncate_epoch = 2; + if (has_truncate_epoch()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NewFileSize::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const NewFileSize* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void NewFileSize::MergeFrom(const NewFileSize& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_size_in_bytes()) { + set_size_in_bytes(from.size_in_bytes()); + } + if (from.has_truncate_epoch()) { + set_truncate_epoch(from.truncate_epoch()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void NewFileSize::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NewFileSize::CopyFrom(const NewFileSize& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NewFileSize::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void NewFileSize::Swap(NewFileSize* other) { + if (other != this) { + std::swap(size_in_bytes_, other->size_in_bytes_); + std::swap(truncate_epoch_, other->truncate_epoch_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata NewFileSize::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = NewFileSize_descriptor_; + metadata.reflection = NewFileSize_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int StripingPolicy::kTypeFieldNumber; +const int StripingPolicy::kStripeSizeFieldNumber; +const int StripingPolicy::kWidthFieldNumber; +const int StripingPolicy::kParityWidthFieldNumber; +#endif // !_MSC_VER + +StripingPolicy::StripingPolicy() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void StripingPolicy::InitAsDefaultInstance() { +} + +StripingPolicy::StripingPolicy(const StripingPolicy& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void StripingPolicy::SharedCtor() { + _cached_size_ = 0; + type_ = 0; + stripe_size_ = 0u; + width_ = 0u; + parity_width_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +StripingPolicy::~StripingPolicy() { + SharedDtor(); +} + +void StripingPolicy::SharedDtor() { + if (this != default_instance_) { + } +} + +void StripingPolicy::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* StripingPolicy::descriptor() { + protobuf_AssignDescriptorsOnce(); + return StripingPolicy_descriptor_; +} + +const StripingPolicy& StripingPolicy::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +StripingPolicy* StripingPolicy::default_instance_ = NULL; + +StripingPolicy* StripingPolicy::New() const { + return new StripingPolicy; +} + +void StripingPolicy::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + type_ = 0; + stripe_size_ = 0u; + width_ = 0u; + parity_width_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool StripingPolicy::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.StripingPolicyType type = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::StripingPolicyType_IsValid(value)) { + set_type(static_cast< ::xtreemfs::pbrpc::StripingPolicyType >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_stripe_size; + break; + } + + // required fixed32 stripe_size = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_stripe_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &stripe_size_))); + set_has_stripe_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_width; + break; + } + + // required fixed32 width = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_width: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &width_))); + set_has_width(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_parity_width; + break; + } + + // optional fixed32 parity_width = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_parity_width: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &parity_width_))); + set_has_parity_width(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void StripingPolicy::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.StripingPolicyType type = 1; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->type(), output); + } + + // required fixed32 stripe_size = 2; + if (has_stripe_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->stripe_size(), output); + } + + // required fixed32 width = 3; + if (has_width()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->width(), output); + } + + // optional fixed32 parity_width = 4; + if (has_parity_width()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->parity_width(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* StripingPolicy::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.StripingPolicyType type = 1; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->type(), target); + } + + // required fixed32 stripe_size = 2; + if (has_stripe_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->stripe_size(), target); + } + + // required fixed32 width = 3; + if (has_width()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->width(), target); + } + + // optional fixed32 parity_width = 4; + if (has_parity_width()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->parity_width(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int StripingPolicy::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.StripingPolicyType type = 1; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + // required fixed32 stripe_size = 2; + if (has_stripe_size()) { + total_size += 1 + 4; + } + + // required fixed32 width = 3; + if (has_width()) { + total_size += 1 + 4; + } + + // optional fixed32 parity_width = 4; + if (has_parity_width()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void StripingPolicy::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const StripingPolicy* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void StripingPolicy::MergeFrom(const StripingPolicy& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_type()) { + set_type(from.type()); + } + if (from.has_stripe_size()) { + set_stripe_size(from.stripe_size()); + } + if (from.has_width()) { + set_width(from.width()); + } + if (from.has_parity_width()) { + set_parity_width(from.parity_width()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void StripingPolicy::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void StripingPolicy::CopyFrom(const StripingPolicy& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StripingPolicy::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void StripingPolicy::Swap(StripingPolicy* other) { + if (other != this) { + std::swap(type_, other->type_); + std::swap(stripe_size_, other->stripe_size_); + std::swap(width_, other->width_); + std::swap(parity_width_, other->parity_width_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata StripingPolicy::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = StripingPolicy_descriptor_; + metadata.reflection = StripingPolicy_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Replica::kOsdUuidsFieldNumber; +const int Replica::kReplicationFlagsFieldNumber; +const int Replica::kStripingPolicyFieldNumber; +#endif // !_MSC_VER + +Replica::Replica() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Replica::InitAsDefaultInstance() { + striping_policy_ = const_cast< ::xtreemfs::pbrpc::StripingPolicy*>(&::xtreemfs::pbrpc::StripingPolicy::default_instance()); +} + +Replica::Replica(const Replica& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Replica::SharedCtor() { + _cached_size_ = 0; + replication_flags_ = 0u; + striping_policy_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Replica::~Replica() { + SharedDtor(); +} + +void Replica::SharedDtor() { + if (this != default_instance_) { + delete striping_policy_; + } +} + +void Replica::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Replica::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Replica_descriptor_; +} + +const Replica& Replica::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +Replica* Replica::default_instance_ = NULL; + +Replica* Replica::New() const { + return new Replica; +} + +void Replica::Clear() { + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + replication_flags_ = 0u; + if (has_striping_policy()) { + if (striping_policy_ != NULL) striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear(); + } + } + osd_uuids_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Replica::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string osd_uuids = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_osd_uuids: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_osd_uuids())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(this->osd_uuids_size() - 1).data(), + this->osd_uuids(this->osd_uuids_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_osd_uuids; + if (input->ExpectTag(21)) goto parse_replication_flags; + break; + } + + // required fixed32 replication_flags = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_replication_flags: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &replication_flags_))); + set_has_replication_flags(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_striping_policy; + break; + } + + // required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_striping_policy: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_striping_policy())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Replica::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated string osd_uuids = 1; + for (int i = 0; i < this->osd_uuids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(i).data(), this->osd_uuids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->osd_uuids(i), output); + } + + // required fixed32 replication_flags = 2; + if (has_replication_flags()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->replication_flags(), output); + } + + // required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3; + if (has_striping_policy()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->striping_policy(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Replica::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated string osd_uuids = 1; + for (int i = 0; i < this->osd_uuids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(i).data(), this->osd_uuids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1, this->osd_uuids(i), target); + } + + // required fixed32 replication_flags = 2; + if (has_replication_flags()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->replication_flags(), target); + } + + // required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3; + if (has_striping_policy()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->striping_policy(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Replica::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // required fixed32 replication_flags = 2; + if (has_replication_flags()) { + total_size += 1 + 4; + } + + // required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3; + if (has_striping_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->striping_policy()); + } + + } + // repeated string osd_uuids = 1; + total_size += 1 * this->osd_uuids_size(); + for (int i = 0; i < this->osd_uuids_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->osd_uuids(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Replica::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Replica* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Replica::MergeFrom(const Replica& from) { + GOOGLE_CHECK_NE(&from, this); + osd_uuids_.MergeFrom(from.osd_uuids_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_replication_flags()) { + set_replication_flags(from.replication_flags()); + } + if (from.has_striping_policy()) { + mutable_striping_policy()->::xtreemfs::pbrpc::StripingPolicy::MergeFrom(from.striping_policy()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Replica::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Replica::CopyFrom(const Replica& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Replica::IsInitialized() const { + if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false; + + if (has_striping_policy()) { + if (!this->striping_policy().IsInitialized()) return false; + } + return true; +} + +void Replica::Swap(Replica* other) { + if (other != this) { + osd_uuids_.Swap(&other->osd_uuids_); + std::swap(replication_flags_, other->replication_flags_); + std::swap(striping_policy_, other->striping_policy_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Replica::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Replica_descriptor_; + metadata.reflection = Replica_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Replicas::kReplicasFieldNumber; +#endif // !_MSC_VER + +Replicas::Replicas() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Replicas::InitAsDefaultInstance() { +} + +Replicas::Replicas(const Replicas& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Replicas::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Replicas::~Replicas() { + SharedDtor(); +} + +void Replicas::SharedDtor() { + if (this != default_instance_) { + } +} + +void Replicas::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Replicas::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Replicas_descriptor_; +} + +const Replicas& Replicas::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +Replicas* Replicas::default_instance_ = NULL; + +Replicas* Replicas::New() const { + return new Replicas; +} + +void Replicas::Clear() { + replicas_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Replicas::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .xtreemfs.pbrpc.Replica replicas = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_replicas: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_replicas())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_replicas; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Replicas::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .xtreemfs.pbrpc.Replica replicas = 1; + for (int i = 0; i < this->replicas_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->replicas(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Replicas::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .xtreemfs.pbrpc.Replica replicas = 1; + for (int i = 0; i < this->replicas_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->replicas(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Replicas::ByteSize() const { + int total_size = 0; + + // repeated .xtreemfs.pbrpc.Replica replicas = 1; + total_size += 1 * this->replicas_size(); + for (int i = 0; i < this->replicas_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->replicas(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Replicas::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Replicas* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Replicas::MergeFrom(const Replicas& from) { + GOOGLE_CHECK_NE(&from, this); + replicas_.MergeFrom(from.replicas_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Replicas::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Replicas::CopyFrom(const Replicas& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Replicas::IsInitialized() const { + + for (int i = 0; i < replicas_size(); i++) { + if (!this->replicas(i).IsInitialized()) return false; + } + return true; +} + +void Replicas::Swap(Replicas* other) { + if (other != this) { + replicas_.Swap(&other->replicas_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Replicas::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Replicas_descriptor_; + metadata.reflection = Replicas_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int XCap::kAccessModeFieldNumber; +const int XCap::kClientIdentityFieldNumber; +const int XCap::kExpireTimeSFieldNumber; +const int XCap::kExpireTimeoutSFieldNumber; +const int XCap::kFileIdFieldNumber; +const int XCap::kReplicateOnCloseFieldNumber; +const int XCap::kServerSignatureFieldNumber; +const int XCap::kTruncateEpochFieldNumber; +const int XCap::kSnapConfigFieldNumber; +const int XCap::kSnapTimestampFieldNumber; +#endif // !_MSC_VER + +XCap::XCap() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void XCap::InitAsDefaultInstance() { +} + +XCap::XCap(const XCap& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void XCap::SharedCtor() { + _cached_size_ = 0; + access_mode_ = 0u; + client_identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + expire_time_s_ = GOOGLE_ULONGLONG(0); + expire_timeout_s_ = 0u; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + replicate_on_close_ = false; + server_signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + truncate_epoch_ = 0u; + snap_config_ = 0; + snap_timestamp_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +XCap::~XCap() { + SharedDtor(); +} + +void XCap::SharedDtor() { + if (client_identity_ != &::google::protobuf::internal::kEmptyString) { + delete client_identity_; + } + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (server_signature_ != &::google::protobuf::internal::kEmptyString) { + delete server_signature_; + } + if (this != default_instance_) { + } +} + +void XCap::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* XCap::descriptor() { + protobuf_AssignDescriptorsOnce(); + return XCap_descriptor_; +} + +const XCap& XCap::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +XCap* XCap::default_instance_ = NULL; + +XCap* XCap::New() const { + return new XCap; +} + +void XCap::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + access_mode_ = 0u; + if (has_client_identity()) { + if (client_identity_ != &::google::protobuf::internal::kEmptyString) { + client_identity_->clear(); + } + } + expire_time_s_ = GOOGLE_ULONGLONG(0); + expire_timeout_s_ = 0u; + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + replicate_on_close_ = false; + if (has_server_signature()) { + if (server_signature_ != &::google::protobuf::internal::kEmptyString) { + server_signature_->clear(); + } + } + truncate_epoch_ = 0u; + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + snap_config_ = 0; + snap_timestamp_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool XCap::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 access_mode = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &access_mode_))); + set_has_access_mode(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_client_identity; + break; + } + + // required string client_identity = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_client_identity: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_client_identity())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->client_identity().data(), this->client_identity().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_expire_time_s; + break; + } + + // required fixed64 expire_time_s = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_expire_time_s: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &expire_time_s_))); + set_has_expire_time_s(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_expire_timeout_s; + break; + } + + // required fixed32 expire_timeout_s = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_expire_timeout_s: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &expire_timeout_s_))); + set_has_expire_timeout_s(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_file_id; + break; + } + + // required string file_id = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_replicate_on_close; + break; + } + + // required bool replicate_on_close = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_replicate_on_close: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &replicate_on_close_))); + set_has_replicate_on_close(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(58)) goto parse_server_signature; + break; + } + + // required string server_signature = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_server_signature: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_server_signature())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->server_signature().data(), this->server_signature().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(69)) goto parse_truncate_epoch; + break; + } + + // required fixed32 truncate_epoch = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_truncate_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &truncate_epoch_))); + set_has_truncate_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(72)) goto parse_snap_config; + break; + } + + // required .xtreemfs.pbrpc.SnapConfig snap_config = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_snap_config: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::SnapConfig_IsValid(value)) { + set_snap_config(static_cast< ::xtreemfs::pbrpc::SnapConfig >(value)); + } else { + mutable_unknown_fields()->AddVarint(9, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(81)) goto parse_snap_timestamp; + break; + } + + // required fixed64 snap_timestamp = 10; + case 10: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_snap_timestamp: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &snap_timestamp_))); + set_has_snap_timestamp(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void XCap::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 access_mode = 1; + if (has_access_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->access_mode(), output); + } + + // required string client_identity = 2; + if (has_client_identity()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->client_identity().data(), this->client_identity().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->client_identity(), output); + } + + // required fixed64 expire_time_s = 3; + if (has_expire_time_s()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->expire_time_s(), output); + } + + // required fixed32 expire_timeout_s = 4; + if (has_expire_timeout_s()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->expire_timeout_s(), output); + } + + // required string file_id = 5; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 5, this->file_id(), output); + } + + // required bool replicate_on_close = 6; + if (has_replicate_on_close()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->replicate_on_close(), output); + } + + // required string server_signature = 7; + if (has_server_signature()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->server_signature().data(), this->server_signature().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 7, this->server_signature(), output); + } + + // required fixed32 truncate_epoch = 8; + if (has_truncate_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(8, this->truncate_epoch(), output); + } + + // required .xtreemfs.pbrpc.SnapConfig snap_config = 9; + if (has_snap_config()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 9, this->snap_config(), output); + } + + // required fixed64 snap_timestamp = 10; + if (has_snap_timestamp()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(10, this->snap_timestamp(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* XCap::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 access_mode = 1; + if (has_access_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->access_mode(), target); + } + + // required string client_identity = 2; + if (has_client_identity()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->client_identity().data(), this->client_identity().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->client_identity(), target); + } + + // required fixed64 expire_time_s = 3; + if (has_expire_time_s()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->expire_time_s(), target); + } + + // required fixed32 expire_timeout_s = 4; + if (has_expire_timeout_s()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->expire_timeout_s(), target); + } + + // required string file_id = 5; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->file_id(), target); + } + + // required bool replicate_on_close = 6; + if (has_replicate_on_close()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->replicate_on_close(), target); + } + + // required string server_signature = 7; + if (has_server_signature()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->server_signature().data(), this->server_signature().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 7, this->server_signature(), target); + } + + // required fixed32 truncate_epoch = 8; + if (has_truncate_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(8, this->truncate_epoch(), target); + } + + // required .xtreemfs.pbrpc.SnapConfig snap_config = 9; + if (has_snap_config()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 9, this->snap_config(), target); + } + + // required fixed64 snap_timestamp = 10; + if (has_snap_timestamp()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(10, this->snap_timestamp(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int XCap::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 access_mode = 1; + if (has_access_mode()) { + total_size += 1 + 4; + } + + // required string client_identity = 2; + if (has_client_identity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->client_identity()); + } + + // required fixed64 expire_time_s = 3; + if (has_expire_time_s()) { + total_size += 1 + 8; + } + + // required fixed32 expire_timeout_s = 4; + if (has_expire_timeout_s()) { + total_size += 1 + 4; + } + + // required string file_id = 5; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required bool replicate_on_close = 6; + if (has_replicate_on_close()) { + total_size += 1 + 1; + } + + // required string server_signature = 7; + if (has_server_signature()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->server_signature()); + } + + // required fixed32 truncate_epoch = 8; + if (has_truncate_epoch()) { + total_size += 1 + 4; + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // required .xtreemfs.pbrpc.SnapConfig snap_config = 9; + if (has_snap_config()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->snap_config()); + } + + // required fixed64 snap_timestamp = 10; + if (has_snap_timestamp()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void XCap::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const XCap* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void XCap::MergeFrom(const XCap& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_access_mode()) { + set_access_mode(from.access_mode()); + } + if (from.has_client_identity()) { + set_client_identity(from.client_identity()); + } + if (from.has_expire_time_s()) { + set_expire_time_s(from.expire_time_s()); + } + if (from.has_expire_timeout_s()) { + set_expire_timeout_s(from.expire_timeout_s()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_replicate_on_close()) { + set_replicate_on_close(from.replicate_on_close()); + } + if (from.has_server_signature()) { + set_server_signature(from.server_signature()); + } + if (from.has_truncate_epoch()) { + set_truncate_epoch(from.truncate_epoch()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_snap_config()) { + set_snap_config(from.snap_config()); + } + if (from.has_snap_timestamp()) { + set_snap_timestamp(from.snap_timestamp()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void XCap::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void XCap::CopyFrom(const XCap& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool XCap::IsInitialized() const { + if ((_has_bits_[0] & 0x000003ff) != 0x000003ff) return false; + + return true; +} + +void XCap::Swap(XCap* other) { + if (other != this) { + std::swap(access_mode_, other->access_mode_); + std::swap(client_identity_, other->client_identity_); + std::swap(expire_time_s_, other->expire_time_s_); + std::swap(expire_timeout_s_, other->expire_timeout_s_); + std::swap(file_id_, other->file_id_); + std::swap(replicate_on_close_, other->replicate_on_close_); + std::swap(server_signature_, other->server_signature_); + std::swap(truncate_epoch_, other->truncate_epoch_); + std::swap(snap_config_, other->snap_config_); + std::swap(snap_timestamp_, other->snap_timestamp_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata XCap::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = XCap_descriptor_; + metadata.reflection = XCap_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int XLocSet::kReadOnlyFileSizeFieldNumber; +const int XLocSet::kReplicasFieldNumber; +const int XLocSet::kReplicaUpdatePolicyFieldNumber; +const int XLocSet::kVersionFieldNumber; +#endif // !_MSC_VER + +XLocSet::XLocSet() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void XLocSet::InitAsDefaultInstance() { +} + +XLocSet::XLocSet(const XLocSet& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void XLocSet::SharedCtor() { + _cached_size_ = 0; + read_only_file_size_ = GOOGLE_ULONGLONG(0); + replica_update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + version_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +XLocSet::~XLocSet() { + SharedDtor(); +} + +void XLocSet::SharedDtor() { + if (replica_update_policy_ != &::google::protobuf::internal::kEmptyString) { + delete replica_update_policy_; + } + if (this != default_instance_) { + } +} + +void XLocSet::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* XLocSet::descriptor() { + protobuf_AssignDescriptorsOnce(); + return XLocSet_descriptor_; +} + +const XLocSet& XLocSet::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +XLocSet* XLocSet::default_instance_ = NULL; + +XLocSet* XLocSet::New() const { + return new XLocSet; +} + +void XLocSet::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + read_only_file_size_ = GOOGLE_ULONGLONG(0); + if (has_replica_update_policy()) { + if (replica_update_policy_ != &::google::protobuf::internal::kEmptyString) { + replica_update_policy_->clear(); + } + } + version_ = 0u; + } + replicas_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool XLocSet::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 read_only_file_size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &read_only_file_size_))); + set_has_read_only_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_replicas; + break; + } + + // repeated .xtreemfs.pbrpc.Replica replicas = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_replicas: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_replicas())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_replicas; + if (input->ExpectTag(26)) goto parse_replica_update_policy; + break; + } + + // required string replica_update_policy = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_replica_update_policy: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_replica_update_policy())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->replica_update_policy().data(), this->replica_update_policy().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_version; + break; + } + + // required fixed32 version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &version_))); + set_has_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void XLocSet::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 read_only_file_size = 1; + if (has_read_only_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->read_only_file_size(), output); + } + + // repeated .xtreemfs.pbrpc.Replica replicas = 2; + for (int i = 0; i < this->replicas_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->replicas(i), output); + } + + // required string replica_update_policy = 3; + if (has_replica_update_policy()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->replica_update_policy().data(), this->replica_update_policy().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->replica_update_policy(), output); + } + + // required fixed32 version = 4; + if (has_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* XLocSet::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 read_only_file_size = 1; + if (has_read_only_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->read_only_file_size(), target); + } + + // repeated .xtreemfs.pbrpc.Replica replicas = 2; + for (int i = 0; i < this->replicas_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->replicas(i), target); + } + + // required string replica_update_policy = 3; + if (has_replica_update_policy()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->replica_update_policy().data(), this->replica_update_policy().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->replica_update_policy(), target); + } + + // required fixed32 version = 4; + if (has_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int XLocSet::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 read_only_file_size = 1; + if (has_read_only_file_size()) { + total_size += 1 + 8; + } + + // required string replica_update_policy = 3; + if (has_replica_update_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->replica_update_policy()); + } + + // required fixed32 version = 4; + if (has_version()) { + total_size += 1 + 4; + } + + } + // repeated .xtreemfs.pbrpc.Replica replicas = 2; + total_size += 1 * this->replicas_size(); + for (int i = 0; i < this->replicas_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->replicas(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void XLocSet::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const XLocSet* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void XLocSet::MergeFrom(const XLocSet& from) { + GOOGLE_CHECK_NE(&from, this); + replicas_.MergeFrom(from.replicas_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_read_only_file_size()) { + set_read_only_file_size(from.read_only_file_size()); + } + if (from.has_replica_update_policy()) { + set_replica_update_policy(from.replica_update_policy()); + } + if (from.has_version()) { + set_version(from.version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void XLocSet::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void XLocSet::CopyFrom(const XLocSet& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool XLocSet::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000d) != 0x0000000d) return false; + + for (int i = 0; i < replicas_size(); i++) { + if (!this->replicas(i).IsInitialized()) return false; + } + return true; +} + +void XLocSet::Swap(XLocSet* other) { + if (other != this) { + std::swap(read_only_file_size_, other->read_only_file_size_); + replicas_.Swap(&other->replicas_); + std::swap(replica_update_policy_, other->replica_update_policy_); + std::swap(version_, other->version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata XLocSet::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = XLocSet_descriptor_; + metadata.reflection = XLocSet_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FileCredentials::kXcapFieldNumber; +const int FileCredentials::kXlocsFieldNumber; +#endif // !_MSC_VER + +FileCredentials::FileCredentials() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void FileCredentials::InitAsDefaultInstance() { + xcap_ = const_cast< ::xtreemfs::pbrpc::XCap*>(&::xtreemfs::pbrpc::XCap::default_instance()); + xlocs_ = const_cast< ::xtreemfs::pbrpc::XLocSet*>(&::xtreemfs::pbrpc::XLocSet::default_instance()); +} + +FileCredentials::FileCredentials(const FileCredentials& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void FileCredentials::SharedCtor() { + _cached_size_ = 0; + xcap_ = NULL; + xlocs_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FileCredentials::~FileCredentials() { + SharedDtor(); +} + +void FileCredentials::SharedDtor() { + if (this != default_instance_) { + delete xcap_; + delete xlocs_; + } +} + +void FileCredentials::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FileCredentials::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FileCredentials_descriptor_; +} + +const FileCredentials& FileCredentials::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +FileCredentials* FileCredentials::default_instance_ = NULL; + +FileCredentials* FileCredentials::New() const { + return new FileCredentials; +} + +void FileCredentials::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_xcap()) { + if (xcap_ != NULL) xcap_->::xtreemfs::pbrpc::XCap::Clear(); + } + if (has_xlocs()) { + if (xlocs_ != NULL) xlocs_->::xtreemfs::pbrpc::XLocSet::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool FileCredentials::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.XCap xcap = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_xcap())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_xlocs; + break; + } + + // required .xtreemfs.pbrpc.XLocSet xlocs = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_xlocs: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_xlocs())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void FileCredentials::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.XCap xcap = 1; + if (has_xcap()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->xcap(), output); + } + + // required .xtreemfs.pbrpc.XLocSet xlocs = 2; + if (has_xlocs()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->xlocs(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* FileCredentials::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.XCap xcap = 1; + if (has_xcap()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->xcap(), target); + } + + // required .xtreemfs.pbrpc.XLocSet xlocs = 2; + if (has_xlocs()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->xlocs(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int FileCredentials::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.XCap xcap = 1; + if (has_xcap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->xcap()); + } + + // required .xtreemfs.pbrpc.XLocSet xlocs = 2; + if (has_xlocs()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->xlocs()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FileCredentials::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const FileCredentials* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void FileCredentials::MergeFrom(const FileCredentials& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_xcap()) { + mutable_xcap()->::xtreemfs::pbrpc::XCap::MergeFrom(from.xcap()); + } + if (from.has_xlocs()) { + mutable_xlocs()->::xtreemfs::pbrpc::XLocSet::MergeFrom(from.xlocs()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void FileCredentials::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FileCredentials::CopyFrom(const FileCredentials& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FileCredentials::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_xcap()) { + if (!this->xcap().IsInitialized()) return false; + } + if (has_xlocs()) { + if (!this->xlocs().IsInitialized()) return false; + } + return true; +} + +void FileCredentials::Swap(FileCredentials* other) { + if (other != this) { + std::swap(xcap_, other->xcap_); + std::swap(xlocs_, other->xlocs_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata FileCredentials::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FileCredentials_descriptor_; + metadata.reflection = FileCredentials_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int FileCredentialsSet::kFileCredentialsFieldNumber; +#endif // !_MSC_VER + +FileCredentialsSet::FileCredentialsSet() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void FileCredentialsSet::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +FileCredentialsSet::FileCredentialsSet(const FileCredentialsSet& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void FileCredentialsSet::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FileCredentialsSet::~FileCredentialsSet() { + SharedDtor(); +} + +void FileCredentialsSet::SharedDtor() { + if (this != default_instance_) { + delete file_credentials_; + } +} + +void FileCredentialsSet::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* FileCredentialsSet::descriptor() { + protobuf_AssignDescriptorsOnce(); + return FileCredentialsSet_descriptor_; +} + +const FileCredentialsSet& FileCredentialsSet::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +FileCredentialsSet* FileCredentialsSet::default_instance_ = NULL; + +FileCredentialsSet* FileCredentialsSet::New() const { + return new FileCredentialsSet; +} + +void FileCredentialsSet::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool FileCredentialsSet::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void FileCredentialsSet::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* FileCredentialsSet::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int FileCredentialsSet::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FileCredentialsSet::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const FileCredentialsSet* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void FileCredentialsSet::MergeFrom(const FileCredentialsSet& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void FileCredentialsSet::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FileCredentialsSet::CopyFrom(const FileCredentialsSet& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FileCredentialsSet::IsInitialized() const { + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void FileCredentialsSet::Swap(FileCredentialsSet* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata FileCredentialsSet::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = FileCredentialsSet_descriptor_; + metadata.reflection = FileCredentialsSet_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int VivaldiCoordinates::kXCoordinateFieldNumber; +const int VivaldiCoordinates::kYCoordinateFieldNumber; +const int VivaldiCoordinates::kLocalErrorFieldNumber; +#endif // !_MSC_VER + +VivaldiCoordinates::VivaldiCoordinates() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void VivaldiCoordinates::InitAsDefaultInstance() { +} + +VivaldiCoordinates::VivaldiCoordinates(const VivaldiCoordinates& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void VivaldiCoordinates::SharedCtor() { + _cached_size_ = 0; + x_coordinate_ = 0; + y_coordinate_ = 0; + local_error_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +VivaldiCoordinates::~VivaldiCoordinates() { + SharedDtor(); +} + +void VivaldiCoordinates::SharedDtor() { + if (this != default_instance_) { + } +} + +void VivaldiCoordinates::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* VivaldiCoordinates::descriptor() { + protobuf_AssignDescriptorsOnce(); + return VivaldiCoordinates_descriptor_; +} + +const VivaldiCoordinates& VivaldiCoordinates::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +VivaldiCoordinates* VivaldiCoordinates::default_instance_ = NULL; + +VivaldiCoordinates* VivaldiCoordinates::New() const { + return new VivaldiCoordinates; +} + +void VivaldiCoordinates::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + x_coordinate_ = 0; + y_coordinate_ = 0; + local_error_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool VivaldiCoordinates::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required double x_coordinate = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &x_coordinate_))); + set_has_x_coordinate(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_y_coordinate; + break; + } + + // required double y_coordinate = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_y_coordinate: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &y_coordinate_))); + set_has_y_coordinate(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_local_error; + break; + } + + // required double local_error = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_local_error: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &local_error_))); + set_has_local_error(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void VivaldiCoordinates::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required double x_coordinate = 1; + if (has_x_coordinate()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->x_coordinate(), output); + } + + // required double y_coordinate = 2; + if (has_y_coordinate()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->y_coordinate(), output); + } + + // required double local_error = 3; + if (has_local_error()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->local_error(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* VivaldiCoordinates::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required double x_coordinate = 1; + if (has_x_coordinate()) { + target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->x_coordinate(), target); + } + + // required double y_coordinate = 2; + if (has_y_coordinate()) { + target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->y_coordinate(), target); + } + + // required double local_error = 3; + if (has_local_error()) { + target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->local_error(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int VivaldiCoordinates::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required double x_coordinate = 1; + if (has_x_coordinate()) { + total_size += 1 + 8; + } + + // required double y_coordinate = 2; + if (has_y_coordinate()) { + total_size += 1 + 8; + } + + // required double local_error = 3; + if (has_local_error()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void VivaldiCoordinates::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const VivaldiCoordinates* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void VivaldiCoordinates::MergeFrom(const VivaldiCoordinates& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_x_coordinate()) { + set_x_coordinate(from.x_coordinate()); + } + if (from.has_y_coordinate()) { + set_y_coordinate(from.y_coordinate()); + } + if (from.has_local_error()) { + set_local_error(from.local_error()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void VivaldiCoordinates::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VivaldiCoordinates::CopyFrom(const VivaldiCoordinates& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VivaldiCoordinates::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void VivaldiCoordinates::Swap(VivaldiCoordinates* other) { + if (other != this) { + std::swap(x_coordinate_, other->x_coordinate_); + std::swap(y_coordinate_, other->y_coordinate_); + std::swap(local_error_, other->local_error_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata VivaldiCoordinates::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = VivaldiCoordinates_descriptor_; + metadata.reflection = VivaldiCoordinates_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int OSDWriteResponse::kSizeInBytesFieldNumber; +const int OSDWriteResponse::kTruncateEpochFieldNumber; +#endif // !_MSC_VER + +OSDWriteResponse::OSDWriteResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void OSDWriteResponse::InitAsDefaultInstance() { +} + +OSDWriteResponse::OSDWriteResponse(const OSDWriteResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void OSDWriteResponse::SharedCtor() { + _cached_size_ = 0; + size_in_bytes_ = GOOGLE_ULONGLONG(0); + truncate_epoch_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +OSDWriteResponse::~OSDWriteResponse() { + SharedDtor(); +} + +void OSDWriteResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void OSDWriteResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* OSDWriteResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return OSDWriteResponse_descriptor_; +} + +const OSDWriteResponse& OSDWriteResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +OSDWriteResponse* OSDWriteResponse::default_instance_ = NULL; + +OSDWriteResponse* OSDWriteResponse::New() const { + return new OSDWriteResponse; +} + +void OSDWriteResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_in_bytes_ = GOOGLE_ULONGLONG(0); + truncate_epoch_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool OSDWriteResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional fixed64 size_in_bytes = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &size_in_bytes_))); + set_has_size_in_bytes(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_truncate_epoch; + break; + } + + // optional fixed32 truncate_epoch = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_truncate_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &truncate_epoch_))); + set_has_truncate_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void OSDWriteResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional fixed64 size_in_bytes = 1; + if (has_size_in_bytes()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->size_in_bytes(), output); + } + + // optional fixed32 truncate_epoch = 2; + if (has_truncate_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->truncate_epoch(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* OSDWriteResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional fixed64 size_in_bytes = 1; + if (has_size_in_bytes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->size_in_bytes(), target); + } + + // optional fixed32 truncate_epoch = 2; + if (has_truncate_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->truncate_epoch(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int OSDWriteResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional fixed64 size_in_bytes = 1; + if (has_size_in_bytes()) { + total_size += 1 + 8; + } + + // optional fixed32 truncate_epoch = 2; + if (has_truncate_epoch()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void OSDWriteResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const OSDWriteResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void OSDWriteResponse::MergeFrom(const OSDWriteResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_size_in_bytes()) { + set_size_in_bytes(from.size_in_bytes()); + } + if (from.has_truncate_epoch()) { + set_truncate_epoch(from.truncate_epoch()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void OSDWriteResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void OSDWriteResponse::CopyFrom(const OSDWriteResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool OSDWriteResponse::IsInitialized() const { + + return true; +} + +void OSDWriteResponse::Swap(OSDWriteResponse* other) { + if (other != this) { + std::swap(size_in_bytes_, other->size_in_bytes_); + std::swap(truncate_epoch_, other->truncate_epoch_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata OSDWriteResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = OSDWriteResponse_descriptor_; + metadata.reflection = OSDWriteResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int KeyValuePair::kKeyFieldNumber; +const int KeyValuePair::kValueFieldNumber; +#endif // !_MSC_VER + +KeyValuePair::KeyValuePair() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void KeyValuePair::InitAsDefaultInstance() { +} + +KeyValuePair::KeyValuePair(const KeyValuePair& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void KeyValuePair::SharedCtor() { + _cached_size_ = 0; + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +KeyValuePair::~KeyValuePair() { + SharedDtor(); +} + +void KeyValuePair::SharedDtor() { + if (key_ != &::google::protobuf::internal::kEmptyString) { + delete key_; + } + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (this != default_instance_) { + } +} + +void KeyValuePair::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* KeyValuePair::descriptor() { + protobuf_AssignDescriptorsOnce(); + return KeyValuePair_descriptor_; +} + +const KeyValuePair& KeyValuePair::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + return *default_instance_; +} + +KeyValuePair* KeyValuePair::default_instance_ = NULL; + +KeyValuePair* KeyValuePair::New() const { + return new KeyValuePair; +} + +void KeyValuePair::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_key()) { + if (key_ != &::google::protobuf::internal::kEmptyString) { + key_->clear(); + } + } + if (has_value()) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool KeyValuePair::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string key = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_key())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->key().data(), this->key().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_value; + break; + } + + // required string value = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_value())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void KeyValuePair::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string key = 1; + if (has_key()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->key().data(), this->key().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->key(), output); + } + + // required string value = 2; + if (has_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->value(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* KeyValuePair::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string key = 1; + if (has_key()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->key().data(), this->key().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->key(), target); + } + + // required string value = 2; + if (has_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->value(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int KeyValuePair::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string key = 1; + if (has_key()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->key()); + } + + // required string value = 2; + if (has_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->value()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void KeyValuePair::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const KeyValuePair* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void KeyValuePair::MergeFrom(const KeyValuePair& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_key()) { + set_key(from.key()); + } + if (from.has_value()) { + set_value(from.value()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void KeyValuePair::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void KeyValuePair::CopyFrom(const KeyValuePair& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool KeyValuePair::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void KeyValuePair::Swap(KeyValuePair* other) { + if (other != this) { + std::swap(key_, other->key_); + std::swap(value_, other->value_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata KeyValuePair::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = KeyValuePair_descriptor_; + metadata.reflection = KeyValuePair_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +// @@protoc_insertion_point(global_scope) diff --git a/cpp/generated/xtreemfs/GlobalTypes.pb.h b/cpp/generated/xtreemfs/GlobalTypes.pb.h new file mode 100644 index 0000000..fdba318 --- /dev/null +++ b/cpp/generated/xtreemfs/GlobalTypes.pb.h @@ -0,0 +1,2713 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: xtreemfs/GlobalTypes.proto + +#ifndef PROTOBUF_xtreemfs_2fGlobalTypes_2eproto__INCLUDED +#define PROTOBUF_xtreemfs_2fGlobalTypes_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2005000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include "include/PBRPC.pb.h" +#include "include/Common.pb.h" +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); +void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); +void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + +class NewFileSize; +class StripingPolicy; +class Replica; +class Replicas; +class XCap; +class XLocSet; +class FileCredentials; +class FileCredentialsSet; +class VivaldiCoordinates; +class OSDWriteResponse; +class KeyValuePair; + +enum AccessControlPolicyType { + ACCESS_CONTROL_POLICY_NULL = 1, + ACCESS_CONTROL_POLICY_POSIX = 2, + ACCESS_CONTROL_POLICY_VOLUME = 3 +}; +bool AccessControlPolicyType_IsValid(int value); +const AccessControlPolicyType AccessControlPolicyType_MIN = ACCESS_CONTROL_POLICY_NULL; +const AccessControlPolicyType AccessControlPolicyType_MAX = ACCESS_CONTROL_POLICY_VOLUME; +const int AccessControlPolicyType_ARRAYSIZE = AccessControlPolicyType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* AccessControlPolicyType_descriptor(); +inline const ::std::string& AccessControlPolicyType_Name(AccessControlPolicyType value) { + return ::google::protobuf::internal::NameOfEnum( + AccessControlPolicyType_descriptor(), value); +} +inline bool AccessControlPolicyType_Parse( + const ::std::string& name, AccessControlPolicyType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + AccessControlPolicyType_descriptor(), name, value); +} +enum OSDSelectionPolicyType { + OSD_SELECTION_POLICY_FILTER_DEFAULT = 1000, + OSD_SELECTION_POLICY_FILTER_FQDN = 1001, + OSD_SELECTION_POLICY_FILTER_UUID = 1002, + OSD_SELECTION_POLICY_GROUP_DCMAP = 2000, + OSD_SELECTION_POLICY_GROUP_FQDN = 2001, + OSD_SELECTION_POLICY_SORT_DCMAP = 3000, + OSD_SELECTION_POLICY_SORT_FQDN = 3001, + OSD_SELECTION_POLICY_SORT_RANDOM = 3002, + OSD_SELECTION_POLICY_SORT_VIVALDI = 3003, + OSD_SELECTION_POLICY_SORT_HOST_ROUND_ROBIN = 3004, + OSD_SELECTION_POLICY_SORT_UUID = 3998, + OSD_SELECTION_POLICY_SORT_REVERSE = 3999 +}; +bool OSDSelectionPolicyType_IsValid(int value); +const OSDSelectionPolicyType OSDSelectionPolicyType_MIN = OSD_SELECTION_POLICY_FILTER_DEFAULT; +const OSDSelectionPolicyType OSDSelectionPolicyType_MAX = OSD_SELECTION_POLICY_SORT_REVERSE; +const int OSDSelectionPolicyType_ARRAYSIZE = OSDSelectionPolicyType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* OSDSelectionPolicyType_descriptor(); +inline const ::std::string& OSDSelectionPolicyType_Name(OSDSelectionPolicyType value) { + return ::google::protobuf::internal::NameOfEnum( + OSDSelectionPolicyType_descriptor(), value); +} +inline bool OSDSelectionPolicyType_Parse( + const ::std::string& name, OSDSelectionPolicyType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + OSDSelectionPolicyType_descriptor(), name, value); +} +enum ReplicaSelectionPolicyType { + REPLICA_SELECTION_POLICY_SIMPLE = 1 +}; +bool ReplicaSelectionPolicyType_IsValid(int value); +const ReplicaSelectionPolicyType ReplicaSelectionPolicyType_MIN = REPLICA_SELECTION_POLICY_SIMPLE; +const ReplicaSelectionPolicyType ReplicaSelectionPolicyType_MAX = REPLICA_SELECTION_POLICY_SIMPLE; +const int ReplicaSelectionPolicyType_ARRAYSIZE = ReplicaSelectionPolicyType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ReplicaSelectionPolicyType_descriptor(); +inline const ::std::string& ReplicaSelectionPolicyType_Name(ReplicaSelectionPolicyType value) { + return ::google::protobuf::internal::NameOfEnum( + ReplicaSelectionPolicyType_descriptor(), value); +} +inline bool ReplicaSelectionPolicyType_Parse( + const ::std::string& name, ReplicaSelectionPolicyType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ReplicaSelectionPolicyType_descriptor(), name, value); +} +enum SnapConfig { + SNAP_CONFIG_SNAPS_DISABLED = 0, + SNAP_CONFIG_ACCESS_CURRENT = 1, + SNAP_CONFIG_ACCESS_SNAP = 2 +}; +bool SnapConfig_IsValid(int value); +const SnapConfig SnapConfig_MIN = SNAP_CONFIG_SNAPS_DISABLED; +const SnapConfig SnapConfig_MAX = SNAP_CONFIG_ACCESS_SNAP; +const int SnapConfig_ARRAYSIZE = SnapConfig_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SnapConfig_descriptor(); +inline const ::std::string& SnapConfig_Name(SnapConfig value) { + return ::google::protobuf::internal::NameOfEnum( + SnapConfig_descriptor(), value); +} +inline bool SnapConfig_Parse( + const ::std::string& name, SnapConfig* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SnapConfig_descriptor(), name, value); +} +enum StripingPolicyType { + STRIPING_POLICY_RAID0 = 0, + STRIPING_POLICY_ERASURECODE = 1 +}; +bool StripingPolicyType_IsValid(int value); +const StripingPolicyType StripingPolicyType_MIN = STRIPING_POLICY_RAID0; +const StripingPolicyType StripingPolicyType_MAX = STRIPING_POLICY_ERASURECODE; +const int StripingPolicyType_ARRAYSIZE = StripingPolicyType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* StripingPolicyType_descriptor(); +inline const ::std::string& StripingPolicyType_Name(StripingPolicyType value) { + return ::google::protobuf::internal::NameOfEnum( + StripingPolicyType_descriptor(), value); +} +inline bool StripingPolicyType_Parse( + const ::std::string& name, StripingPolicyType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + StripingPolicyType_descriptor(), name, value); +} +enum LeaseState { + NONE = 0, + PRIMARY = 1, + BACKUP = 2, + IDLE = 3 +}; +bool LeaseState_IsValid(int value); +const LeaseState LeaseState_MIN = NONE; +const LeaseState LeaseState_MAX = IDLE; +const int LeaseState_ARRAYSIZE = LeaseState_MAX + 1; + +const ::google::protobuf::EnumDescriptor* LeaseState_descriptor(); +inline const ::std::string& LeaseState_Name(LeaseState value) { + return ::google::protobuf::internal::NameOfEnum( + LeaseState_descriptor(), value); +} +inline bool LeaseState_Parse( + const ::std::string& name, LeaseState* value) { + return ::google::protobuf::internal::ParseNamedEnum( + LeaseState_descriptor(), name, value); +} +enum PORTS { + DIR_HTTP_PORT_DEFAULT = 30638, + DIR_PBRPC_PORT_DEFAULT = 32638, + MRC_HTTP_PORT_DEFAULT = 30636, + MRC_PBRPC_PORT_DEFAULT = 32636, + OSD_HTTP_PORT_DEFAULT = 30640, + OSD_PBRPC_PORT_DEFAULT = 32640 +}; +bool PORTS_IsValid(int value); +const PORTS PORTS_MIN = MRC_HTTP_PORT_DEFAULT; +const PORTS PORTS_MAX = OSD_PBRPC_PORT_DEFAULT; +const int PORTS_ARRAYSIZE = PORTS_MAX + 1; + +const ::google::protobuf::EnumDescriptor* PORTS_descriptor(); +inline const ::std::string& PORTS_Name(PORTS value) { + return ::google::protobuf::internal::NameOfEnum( + PORTS_descriptor(), value); +} +inline bool PORTS_Parse( + const ::std::string& name, PORTS* value) { + return ::google::protobuf::internal::ParseNamedEnum( + PORTS_descriptor(), name, value); +} +enum CONSTANTS { + XCAP_RENEW_INTERVAL_IN_MIN = 1 +}; +bool CONSTANTS_IsValid(int value); +const CONSTANTS CONSTANTS_MIN = XCAP_RENEW_INTERVAL_IN_MIN; +const CONSTANTS CONSTANTS_MAX = XCAP_RENEW_INTERVAL_IN_MIN; +const int CONSTANTS_ARRAYSIZE = CONSTANTS_MAX + 1; + +const ::google::protobuf::EnumDescriptor* CONSTANTS_descriptor(); +inline const ::std::string& CONSTANTS_Name(CONSTANTS value) { + return ::google::protobuf::internal::NameOfEnum( + CONSTANTS_descriptor(), value); +} +inline bool CONSTANTS_Parse( + const ::std::string& name, CONSTANTS* value) { + return ::google::protobuf::internal::ParseNamedEnum( + CONSTANTS_descriptor(), name, value); +} +enum SYSTEM_V_FCNTL { + SYSTEM_V_FCNTL_H_O_RDONLY = 0, + SYSTEM_V_FCNTL_H_O_WRONLY = 1, + SYSTEM_V_FCNTL_H_O_RDWR = 2, + SYSTEM_V_FCNTL_H_O_APPEND = 8, + SYSTEM_V_FCNTL_H_O_CREAT = 256, + SYSTEM_V_FCNTL_H_O_TRUNC = 512, + SYSTEM_V_FCNTL_H_O_EXCL = 1024, + SYSTEM_V_FCNTL_H_O_SYNC = 16, + SYSTEM_V_FCNTL_H_S_IFREG = 32768, + SYSTEM_V_FCNTL_H_S_IFDIR = 16384, + SYSTEM_V_FCNTL_H_S_IFLNK = 40960, + SYSTEM_V_FCNTL_H_S_IFIFO = 4096 +}; +bool SYSTEM_V_FCNTL_IsValid(int value); +const SYSTEM_V_FCNTL SYSTEM_V_FCNTL_MIN = SYSTEM_V_FCNTL_H_O_RDONLY; +const SYSTEM_V_FCNTL SYSTEM_V_FCNTL_MAX = SYSTEM_V_FCNTL_H_S_IFLNK; +const int SYSTEM_V_FCNTL_ARRAYSIZE = SYSTEM_V_FCNTL_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SYSTEM_V_FCNTL_descriptor(); +inline const ::std::string& SYSTEM_V_FCNTL_Name(SYSTEM_V_FCNTL value) { + return ::google::protobuf::internal::NameOfEnum( + SYSTEM_V_FCNTL_descriptor(), value); +} +inline bool SYSTEM_V_FCNTL_Parse( + const ::std::string& name, SYSTEM_V_FCNTL* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SYSTEM_V_FCNTL_descriptor(), name, value); +} +enum REPL_FLAG { + REPL_FLAG_FULL_REPLICA = 1, + REPL_FLAG_IS_COMPLETE = 2, + REPL_FLAG_STRATEGY_RANDOM = 4, + REPL_FLAG_STRATEGY_RAREST_FIRST = 8, + REPL_FLAG_STRATEGY_SEQUENTIAL = 16, + REPL_FLAG_STRATEGY_SEQUENTIAL_PREFETCHING = 32 +}; +bool REPL_FLAG_IsValid(int value); +const REPL_FLAG REPL_FLAG_MIN = REPL_FLAG_FULL_REPLICA; +const REPL_FLAG REPL_FLAG_MAX = REPL_FLAG_STRATEGY_SEQUENTIAL_PREFETCHING; +const int REPL_FLAG_ARRAYSIZE = REPL_FLAG_MAX + 1; + +const ::google::protobuf::EnumDescriptor* REPL_FLAG_descriptor(); +inline const ::std::string& REPL_FLAG_Name(REPL_FLAG value) { + return ::google::protobuf::internal::NameOfEnum( + REPL_FLAG_descriptor(), value); +} +inline bool REPL_FLAG_Parse( + const ::std::string& name, REPL_FLAG* value) { + return ::google::protobuf::internal::ParseNamedEnum( + REPL_FLAG_descriptor(), name, value); +} +enum SERVICES { + DIR = 1, + MRC = 2, + OSD = 3 +}; +bool SERVICES_IsValid(int value); +const SERVICES SERVICES_MIN = DIR; +const SERVICES SERVICES_MAX = OSD; +const int SERVICES_ARRAYSIZE = SERVICES_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SERVICES_descriptor(); +inline const ::std::string& SERVICES_Name(SERVICES value) { + return ::google::protobuf::internal::NameOfEnum( + SERVICES_descriptor(), value); +} +inline bool SERVICES_Parse( + const ::std::string& name, SERVICES* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SERVICES_descriptor(), name, value); +} +// =================================================================== + +class NewFileSize : public ::google::protobuf::Message { + public: + NewFileSize(); + virtual ~NewFileSize(); + + NewFileSize(const NewFileSize& from); + + inline NewFileSize& operator=(const NewFileSize& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const NewFileSize& default_instance(); + + void Swap(NewFileSize* other); + + // implements Message ---------------------------------------------- + + NewFileSize* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const NewFileSize& from); + void MergeFrom(const NewFileSize& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 size_in_bytes = 1; + inline bool has_size_in_bytes() const; + inline void clear_size_in_bytes(); + static const int kSizeInBytesFieldNumber = 1; + inline ::google::protobuf::uint64 size_in_bytes() const; + inline void set_size_in_bytes(::google::protobuf::uint64 value); + + // required fixed32 truncate_epoch = 2; + inline bool has_truncate_epoch() const; + inline void clear_truncate_epoch(); + static const int kTruncateEpochFieldNumber = 2; + inline ::google::protobuf::uint32 truncate_epoch() const; + inline void set_truncate_epoch(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.NewFileSize) + private: + inline void set_has_size_in_bytes(); + inline void clear_has_size_in_bytes(); + inline void set_has_truncate_epoch(); + inline void clear_has_truncate_epoch(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 size_in_bytes_; + ::google::protobuf::uint32 truncate_epoch_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static NewFileSize* default_instance_; +}; +// ------------------------------------------------------------------- + +class StripingPolicy : public ::google::protobuf::Message { + public: + StripingPolicy(); + virtual ~StripingPolicy(); + + StripingPolicy(const StripingPolicy& from); + + inline StripingPolicy& operator=(const StripingPolicy& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const StripingPolicy& default_instance(); + + void Swap(StripingPolicy* other); + + // implements Message ---------------------------------------------- + + StripingPolicy* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const StripingPolicy& from); + void MergeFrom(const StripingPolicy& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.StripingPolicyType type = 1; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 1; + inline ::xtreemfs::pbrpc::StripingPolicyType type() const; + inline void set_type(::xtreemfs::pbrpc::StripingPolicyType value); + + // required fixed32 stripe_size = 2; + inline bool has_stripe_size() const; + inline void clear_stripe_size(); + static const int kStripeSizeFieldNumber = 2; + inline ::google::protobuf::uint32 stripe_size() const; + inline void set_stripe_size(::google::protobuf::uint32 value); + + // required fixed32 width = 3; + inline bool has_width() const; + inline void clear_width(); + static const int kWidthFieldNumber = 3; + inline ::google::protobuf::uint32 width() const; + inline void set_width(::google::protobuf::uint32 value); + + // optional fixed32 parity_width = 4; + inline bool has_parity_width() const; + inline void clear_parity_width(); + static const int kParityWidthFieldNumber = 4; + inline ::google::protobuf::uint32 parity_width() const; + inline void set_parity_width(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.StripingPolicy) + private: + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_stripe_size(); + inline void clear_has_stripe_size(); + inline void set_has_width(); + inline void clear_has_width(); + inline void set_has_parity_width(); + inline void clear_has_parity_width(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + int type_; + ::google::protobuf::uint32 stripe_size_; + ::google::protobuf::uint32 width_; + ::google::protobuf::uint32 parity_width_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static StripingPolicy* default_instance_; +}; +// ------------------------------------------------------------------- + +class Replica : public ::google::protobuf::Message { + public: + Replica(); + virtual ~Replica(); + + Replica(const Replica& from); + + inline Replica& operator=(const Replica& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Replica& default_instance(); + + void Swap(Replica* other); + + // implements Message ---------------------------------------------- + + Replica* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Replica& from); + void MergeFrom(const Replica& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated string osd_uuids = 1; + inline int osd_uuids_size() const; + inline void clear_osd_uuids(); + static const int kOsdUuidsFieldNumber = 1; + inline const ::std::string& osd_uuids(int index) const; + inline ::std::string* mutable_osd_uuids(int index); + inline void set_osd_uuids(int index, const ::std::string& value); + inline void set_osd_uuids(int index, const char* value); + inline void set_osd_uuids(int index, const char* value, size_t size); + inline ::std::string* add_osd_uuids(); + inline void add_osd_uuids(const ::std::string& value); + inline void add_osd_uuids(const char* value); + inline void add_osd_uuids(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& osd_uuids() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_osd_uuids(); + + // required fixed32 replication_flags = 2; + inline bool has_replication_flags() const; + inline void clear_replication_flags(); + static const int kReplicationFlagsFieldNumber = 2; + inline ::google::protobuf::uint32 replication_flags() const; + inline void set_replication_flags(::google::protobuf::uint32 value); + + // required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3; + inline bool has_striping_policy() const; + inline void clear_striping_policy(); + static const int kStripingPolicyFieldNumber = 3; + inline const ::xtreemfs::pbrpc::StripingPolicy& striping_policy() const; + inline ::xtreemfs::pbrpc::StripingPolicy* mutable_striping_policy(); + inline ::xtreemfs::pbrpc::StripingPolicy* release_striping_policy(); + inline void set_allocated_striping_policy(::xtreemfs::pbrpc::StripingPolicy* striping_policy); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Replica) + private: + inline void set_has_replication_flags(); + inline void clear_has_replication_flags(); + inline void set_has_striping_policy(); + inline void clear_has_striping_policy(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::std::string> osd_uuids_; + ::xtreemfs::pbrpc::StripingPolicy* striping_policy_; + ::google::protobuf::uint32 replication_flags_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static Replica* default_instance_; +}; +// ------------------------------------------------------------------- + +class Replicas : public ::google::protobuf::Message { + public: + Replicas(); + virtual ~Replicas(); + + Replicas(const Replicas& from); + + inline Replicas& operator=(const Replicas& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Replicas& default_instance(); + + void Swap(Replicas* other); + + // implements Message ---------------------------------------------- + + Replicas* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Replicas& from); + void MergeFrom(const Replicas& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .xtreemfs.pbrpc.Replica replicas = 1; + inline int replicas_size() const; + inline void clear_replicas(); + static const int kReplicasFieldNumber = 1; + inline const ::xtreemfs::pbrpc::Replica& replicas(int index) const; + inline ::xtreemfs::pbrpc::Replica* mutable_replicas(int index); + inline ::xtreemfs::pbrpc::Replica* add_replicas(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica >& + replicas() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica >* + mutable_replicas(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Replicas) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica > replicas_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static Replicas* default_instance_; +}; +// ------------------------------------------------------------------- + +class XCap : public ::google::protobuf::Message { + public: + XCap(); + virtual ~XCap(); + + XCap(const XCap& from); + + inline XCap& operator=(const XCap& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const XCap& default_instance(); + + void Swap(XCap* other); + + // implements Message ---------------------------------------------- + + XCap* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const XCap& from); + void MergeFrom(const XCap& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 access_mode = 1; + inline bool has_access_mode() const; + inline void clear_access_mode(); + static const int kAccessModeFieldNumber = 1; + inline ::google::protobuf::uint32 access_mode() const; + inline void set_access_mode(::google::protobuf::uint32 value); + + // required string client_identity = 2; + inline bool has_client_identity() const; + inline void clear_client_identity(); + static const int kClientIdentityFieldNumber = 2; + inline const ::std::string& client_identity() const; + inline void set_client_identity(const ::std::string& value); + inline void set_client_identity(const char* value); + inline void set_client_identity(const char* value, size_t size); + inline ::std::string* mutable_client_identity(); + inline ::std::string* release_client_identity(); + inline void set_allocated_client_identity(::std::string* client_identity); + + // required fixed64 expire_time_s = 3; + inline bool has_expire_time_s() const; + inline void clear_expire_time_s(); + static const int kExpireTimeSFieldNumber = 3; + inline ::google::protobuf::uint64 expire_time_s() const; + inline void set_expire_time_s(::google::protobuf::uint64 value); + + // required fixed32 expire_timeout_s = 4; + inline bool has_expire_timeout_s() const; + inline void clear_expire_timeout_s(); + static const int kExpireTimeoutSFieldNumber = 4; + inline ::google::protobuf::uint32 expire_timeout_s() const; + inline void set_expire_timeout_s(::google::protobuf::uint32 value); + + // required string file_id = 5; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 5; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required bool replicate_on_close = 6; + inline bool has_replicate_on_close() const; + inline void clear_replicate_on_close(); + static const int kReplicateOnCloseFieldNumber = 6; + inline bool replicate_on_close() const; + inline void set_replicate_on_close(bool value); + + // required string server_signature = 7; + inline bool has_server_signature() const; + inline void clear_server_signature(); + static const int kServerSignatureFieldNumber = 7; + inline const ::std::string& server_signature() const; + inline void set_server_signature(const ::std::string& value); + inline void set_server_signature(const char* value); + inline void set_server_signature(const char* value, size_t size); + inline ::std::string* mutable_server_signature(); + inline ::std::string* release_server_signature(); + inline void set_allocated_server_signature(::std::string* server_signature); + + // required fixed32 truncate_epoch = 8; + inline bool has_truncate_epoch() const; + inline void clear_truncate_epoch(); + static const int kTruncateEpochFieldNumber = 8; + inline ::google::protobuf::uint32 truncate_epoch() const; + inline void set_truncate_epoch(::google::protobuf::uint32 value); + + // required .xtreemfs.pbrpc.SnapConfig snap_config = 9; + inline bool has_snap_config() const; + inline void clear_snap_config(); + static const int kSnapConfigFieldNumber = 9; + inline ::xtreemfs::pbrpc::SnapConfig snap_config() const; + inline void set_snap_config(::xtreemfs::pbrpc::SnapConfig value); + + // required fixed64 snap_timestamp = 10; + inline bool has_snap_timestamp() const; + inline void clear_snap_timestamp(); + static const int kSnapTimestampFieldNumber = 10; + inline ::google::protobuf::uint64 snap_timestamp() const; + inline void set_snap_timestamp(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.XCap) + private: + inline void set_has_access_mode(); + inline void clear_has_access_mode(); + inline void set_has_client_identity(); + inline void clear_has_client_identity(); + inline void set_has_expire_time_s(); + inline void clear_has_expire_time_s(); + inline void set_has_expire_timeout_s(); + inline void clear_has_expire_timeout_s(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_replicate_on_close(); + inline void clear_has_replicate_on_close(); + inline void set_has_server_signature(); + inline void clear_has_server_signature(); + inline void set_has_truncate_epoch(); + inline void clear_has_truncate_epoch(); + inline void set_has_snap_config(); + inline void clear_has_snap_config(); + inline void set_has_snap_timestamp(); + inline void clear_has_snap_timestamp(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* client_identity_; + ::google::protobuf::uint32 access_mode_; + ::google::protobuf::uint32 expire_timeout_s_; + ::google::protobuf::uint64 expire_time_s_; + ::std::string* file_id_; + ::std::string* server_signature_; + bool replicate_on_close_; + ::google::protobuf::uint32 truncate_epoch_; + ::google::protobuf::uint64 snap_timestamp_; + int snap_config_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(10 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static XCap* default_instance_; +}; +// ------------------------------------------------------------------- + +class XLocSet : public ::google::protobuf::Message { + public: + XLocSet(); + virtual ~XLocSet(); + + XLocSet(const XLocSet& from); + + inline XLocSet& operator=(const XLocSet& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const XLocSet& default_instance(); + + void Swap(XLocSet* other); + + // implements Message ---------------------------------------------- + + XLocSet* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const XLocSet& from); + void MergeFrom(const XLocSet& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 read_only_file_size = 1; + inline bool has_read_only_file_size() const; + inline void clear_read_only_file_size(); + static const int kReadOnlyFileSizeFieldNumber = 1; + inline ::google::protobuf::uint64 read_only_file_size() const; + inline void set_read_only_file_size(::google::protobuf::uint64 value); + + // repeated .xtreemfs.pbrpc.Replica replicas = 2; + inline int replicas_size() const; + inline void clear_replicas(); + static const int kReplicasFieldNumber = 2; + inline const ::xtreemfs::pbrpc::Replica& replicas(int index) const; + inline ::xtreemfs::pbrpc::Replica* mutable_replicas(int index); + inline ::xtreemfs::pbrpc::Replica* add_replicas(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica >& + replicas() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica >* + mutable_replicas(); + + // required string replica_update_policy = 3; + inline bool has_replica_update_policy() const; + inline void clear_replica_update_policy(); + static const int kReplicaUpdatePolicyFieldNumber = 3; + inline const ::std::string& replica_update_policy() const; + inline void set_replica_update_policy(const ::std::string& value); + inline void set_replica_update_policy(const char* value); + inline void set_replica_update_policy(const char* value, size_t size); + inline ::std::string* mutable_replica_update_policy(); + inline ::std::string* release_replica_update_policy(); + inline void set_allocated_replica_update_policy(::std::string* replica_update_policy); + + // required fixed32 version = 4; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 4; + inline ::google::protobuf::uint32 version() const; + inline void set_version(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.XLocSet) + private: + inline void set_has_read_only_file_size(); + inline void clear_has_read_only_file_size(); + inline void set_has_replica_update_policy(); + inline void clear_has_replica_update_policy(); + inline void set_has_version(); + inline void clear_has_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 read_only_file_size_; + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica > replicas_; + ::std::string* replica_update_policy_; + ::google::protobuf::uint32 version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static XLocSet* default_instance_; +}; +// ------------------------------------------------------------------- + +class FileCredentials : public ::google::protobuf::Message { + public: + FileCredentials(); + virtual ~FileCredentials(); + + FileCredentials(const FileCredentials& from); + + inline FileCredentials& operator=(const FileCredentials& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FileCredentials& default_instance(); + + void Swap(FileCredentials* other); + + // implements Message ---------------------------------------------- + + FileCredentials* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FileCredentials& from); + void MergeFrom(const FileCredentials& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.XCap xcap = 1; + inline bool has_xcap() const; + inline void clear_xcap(); + static const int kXcapFieldNumber = 1; + inline const ::xtreemfs::pbrpc::XCap& xcap() const; + inline ::xtreemfs::pbrpc::XCap* mutable_xcap(); + inline ::xtreemfs::pbrpc::XCap* release_xcap(); + inline void set_allocated_xcap(::xtreemfs::pbrpc::XCap* xcap); + + // required .xtreemfs.pbrpc.XLocSet xlocs = 2; + inline bool has_xlocs() const; + inline void clear_xlocs(); + static const int kXlocsFieldNumber = 2; + inline const ::xtreemfs::pbrpc::XLocSet& xlocs() const; + inline ::xtreemfs::pbrpc::XLocSet* mutable_xlocs(); + inline ::xtreemfs::pbrpc::XLocSet* release_xlocs(); + inline void set_allocated_xlocs(::xtreemfs::pbrpc::XLocSet* xlocs); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.FileCredentials) + private: + inline void set_has_xcap(); + inline void clear_has_xcap(); + inline void set_has_xlocs(); + inline void clear_has_xlocs(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::XCap* xcap_; + ::xtreemfs::pbrpc::XLocSet* xlocs_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static FileCredentials* default_instance_; +}; +// ------------------------------------------------------------------- + +class FileCredentialsSet : public ::google::protobuf::Message { + public: + FileCredentialsSet(); + virtual ~FileCredentialsSet(); + + FileCredentialsSet(const FileCredentialsSet& from); + + inline FileCredentialsSet& operator=(const FileCredentialsSet& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const FileCredentialsSet& default_instance(); + + void Swap(FileCredentialsSet* other); + + // implements Message ---------------------------------------------- + + FileCredentialsSet* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const FileCredentialsSet& from); + void MergeFrom(const FileCredentialsSet& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.FileCredentialsSet) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static FileCredentialsSet* default_instance_; +}; +// ------------------------------------------------------------------- + +class VivaldiCoordinates : public ::google::protobuf::Message { + public: + VivaldiCoordinates(); + virtual ~VivaldiCoordinates(); + + VivaldiCoordinates(const VivaldiCoordinates& from); + + inline VivaldiCoordinates& operator=(const VivaldiCoordinates& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const VivaldiCoordinates& default_instance(); + + void Swap(VivaldiCoordinates* other); + + // implements Message ---------------------------------------------- + + VivaldiCoordinates* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const VivaldiCoordinates& from); + void MergeFrom(const VivaldiCoordinates& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required double x_coordinate = 1; + inline bool has_x_coordinate() const; + inline void clear_x_coordinate(); + static const int kXCoordinateFieldNumber = 1; + inline double x_coordinate() const; + inline void set_x_coordinate(double value); + + // required double y_coordinate = 2; + inline bool has_y_coordinate() const; + inline void clear_y_coordinate(); + static const int kYCoordinateFieldNumber = 2; + inline double y_coordinate() const; + inline void set_y_coordinate(double value); + + // required double local_error = 3; + inline bool has_local_error() const; + inline void clear_local_error(); + static const int kLocalErrorFieldNumber = 3; + inline double local_error() const; + inline void set_local_error(double value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.VivaldiCoordinates) + private: + inline void set_has_x_coordinate(); + inline void clear_has_x_coordinate(); + inline void set_has_y_coordinate(); + inline void clear_has_y_coordinate(); + inline void set_has_local_error(); + inline void clear_has_local_error(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + double x_coordinate_; + double y_coordinate_; + double local_error_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static VivaldiCoordinates* default_instance_; +}; +// ------------------------------------------------------------------- + +class OSDWriteResponse : public ::google::protobuf::Message { + public: + OSDWriteResponse(); + virtual ~OSDWriteResponse(); + + OSDWriteResponse(const OSDWriteResponse& from); + + inline OSDWriteResponse& operator=(const OSDWriteResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const OSDWriteResponse& default_instance(); + + void Swap(OSDWriteResponse* other); + + // implements Message ---------------------------------------------- + + OSDWriteResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const OSDWriteResponse& from); + void MergeFrom(const OSDWriteResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional fixed64 size_in_bytes = 1; + inline bool has_size_in_bytes() const; + inline void clear_size_in_bytes(); + static const int kSizeInBytesFieldNumber = 1; + inline ::google::protobuf::uint64 size_in_bytes() const; + inline void set_size_in_bytes(::google::protobuf::uint64 value); + + // optional fixed32 truncate_epoch = 2; + inline bool has_truncate_epoch() const; + inline void clear_truncate_epoch(); + static const int kTruncateEpochFieldNumber = 2; + inline ::google::protobuf::uint32 truncate_epoch() const; + inline void set_truncate_epoch(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.OSDWriteResponse) + private: + inline void set_has_size_in_bytes(); + inline void clear_has_size_in_bytes(); + inline void set_has_truncate_epoch(); + inline void clear_has_truncate_epoch(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 size_in_bytes_; + ::google::protobuf::uint32 truncate_epoch_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static OSDWriteResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class KeyValuePair : public ::google::protobuf::Message { + public: + KeyValuePair(); + virtual ~KeyValuePair(); + + KeyValuePair(const KeyValuePair& from); + + inline KeyValuePair& operator=(const KeyValuePair& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const KeyValuePair& default_instance(); + + void Swap(KeyValuePair* other); + + // implements Message ---------------------------------------------- + + KeyValuePair* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const KeyValuePair& from); + void MergeFrom(const KeyValuePair& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string key = 1; + inline bool has_key() const; + inline void clear_key(); + static const int kKeyFieldNumber = 1; + inline const ::std::string& key() const; + inline void set_key(const ::std::string& value); + inline void set_key(const char* value); + inline void set_key(const char* value, size_t size); + inline ::std::string* mutable_key(); + inline ::std::string* release_key(); + inline void set_allocated_key(::std::string* key); + + // required string value = 2; + inline bool has_value() const; + inline void clear_value(); + static const int kValueFieldNumber = 2; + inline const ::std::string& value() const; + inline void set_value(const ::std::string& value); + inline void set_value(const char* value); + inline void set_value(const char* value, size_t size); + inline ::std::string* mutable_value(); + inline ::std::string* release_value(); + inline void set_allocated_value(::std::string* value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.KeyValuePair) + private: + inline void set_has_key(); + inline void clear_has_key(); + inline void set_has_value(); + inline void clear_has_value(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* key_; + ::std::string* value_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fGlobalTypes_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fGlobalTypes_2eproto(); + + void InitAsDefaultInstance(); + static KeyValuePair* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// NewFileSize + +// required fixed64 size_in_bytes = 1; +inline bool NewFileSize::has_size_in_bytes() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void NewFileSize::set_has_size_in_bytes() { + _has_bits_[0] |= 0x00000001u; +} +inline void NewFileSize::clear_has_size_in_bytes() { + _has_bits_[0] &= ~0x00000001u; +} +inline void NewFileSize::clear_size_in_bytes() { + size_in_bytes_ = GOOGLE_ULONGLONG(0); + clear_has_size_in_bytes(); +} +inline ::google::protobuf::uint64 NewFileSize::size_in_bytes() const { + return size_in_bytes_; +} +inline void NewFileSize::set_size_in_bytes(::google::protobuf::uint64 value) { + set_has_size_in_bytes(); + size_in_bytes_ = value; +} + +// required fixed32 truncate_epoch = 2; +inline bool NewFileSize::has_truncate_epoch() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void NewFileSize::set_has_truncate_epoch() { + _has_bits_[0] |= 0x00000002u; +} +inline void NewFileSize::clear_has_truncate_epoch() { + _has_bits_[0] &= ~0x00000002u; +} +inline void NewFileSize::clear_truncate_epoch() { + truncate_epoch_ = 0u; + clear_has_truncate_epoch(); +} +inline ::google::protobuf::uint32 NewFileSize::truncate_epoch() const { + return truncate_epoch_; +} +inline void NewFileSize::set_truncate_epoch(::google::protobuf::uint32 value) { + set_has_truncate_epoch(); + truncate_epoch_ = value; +} + +// ------------------------------------------------------------------- + +// StripingPolicy + +// required .xtreemfs.pbrpc.StripingPolicyType type = 1; +inline bool StripingPolicy::has_type() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void StripingPolicy::set_has_type() { + _has_bits_[0] |= 0x00000001u; +} +inline void StripingPolicy::clear_has_type() { + _has_bits_[0] &= ~0x00000001u; +} +inline void StripingPolicy::clear_type() { + type_ = 0; + clear_has_type(); +} +inline ::xtreemfs::pbrpc::StripingPolicyType StripingPolicy::type() const { + return static_cast< ::xtreemfs::pbrpc::StripingPolicyType >(type_); +} +inline void StripingPolicy::set_type(::xtreemfs::pbrpc::StripingPolicyType value) { + assert(::xtreemfs::pbrpc::StripingPolicyType_IsValid(value)); + set_has_type(); + type_ = value; +} + +// required fixed32 stripe_size = 2; +inline bool StripingPolicy::has_stripe_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void StripingPolicy::set_has_stripe_size() { + _has_bits_[0] |= 0x00000002u; +} +inline void StripingPolicy::clear_has_stripe_size() { + _has_bits_[0] &= ~0x00000002u; +} +inline void StripingPolicy::clear_stripe_size() { + stripe_size_ = 0u; + clear_has_stripe_size(); +} +inline ::google::protobuf::uint32 StripingPolicy::stripe_size() const { + return stripe_size_; +} +inline void StripingPolicy::set_stripe_size(::google::protobuf::uint32 value) { + set_has_stripe_size(); + stripe_size_ = value; +} + +// required fixed32 width = 3; +inline bool StripingPolicy::has_width() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void StripingPolicy::set_has_width() { + _has_bits_[0] |= 0x00000004u; +} +inline void StripingPolicy::clear_has_width() { + _has_bits_[0] &= ~0x00000004u; +} +inline void StripingPolicy::clear_width() { + width_ = 0u; + clear_has_width(); +} +inline ::google::protobuf::uint32 StripingPolicy::width() const { + return width_; +} +inline void StripingPolicy::set_width(::google::protobuf::uint32 value) { + set_has_width(); + width_ = value; +} + +// optional fixed32 parity_width = 4; +inline bool StripingPolicy::has_parity_width() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void StripingPolicy::set_has_parity_width() { + _has_bits_[0] |= 0x00000008u; +} +inline void StripingPolicy::clear_has_parity_width() { + _has_bits_[0] &= ~0x00000008u; +} +inline void StripingPolicy::clear_parity_width() { + parity_width_ = 0u; + clear_has_parity_width(); +} +inline ::google::protobuf::uint32 StripingPolicy::parity_width() const { + return parity_width_; +} +inline void StripingPolicy::set_parity_width(::google::protobuf::uint32 value) { + set_has_parity_width(); + parity_width_ = value; +} + +// ------------------------------------------------------------------- + +// Replica + +// repeated string osd_uuids = 1; +inline int Replica::osd_uuids_size() const { + return osd_uuids_.size(); +} +inline void Replica::clear_osd_uuids() { + osd_uuids_.Clear(); +} +inline const ::std::string& Replica::osd_uuids(int index) const { + return osd_uuids_.Get(index); +} +inline ::std::string* Replica::mutable_osd_uuids(int index) { + return osd_uuids_.Mutable(index); +} +inline void Replica::set_osd_uuids(int index, const ::std::string& value) { + osd_uuids_.Mutable(index)->assign(value); +} +inline void Replica::set_osd_uuids(int index, const char* value) { + osd_uuids_.Mutable(index)->assign(value); +} +inline void Replica::set_osd_uuids(int index, const char* value, size_t size) { + osd_uuids_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* Replica::add_osd_uuids() { + return osd_uuids_.Add(); +} +inline void Replica::add_osd_uuids(const ::std::string& value) { + osd_uuids_.Add()->assign(value); +} +inline void Replica::add_osd_uuids(const char* value) { + osd_uuids_.Add()->assign(value); +} +inline void Replica::add_osd_uuids(const char* value, size_t size) { + osd_uuids_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +Replica::osd_uuids() const { + return osd_uuids_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +Replica::mutable_osd_uuids() { + return &osd_uuids_; +} + +// required fixed32 replication_flags = 2; +inline bool Replica::has_replication_flags() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Replica::set_has_replication_flags() { + _has_bits_[0] |= 0x00000002u; +} +inline void Replica::clear_has_replication_flags() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Replica::clear_replication_flags() { + replication_flags_ = 0u; + clear_has_replication_flags(); +} +inline ::google::protobuf::uint32 Replica::replication_flags() const { + return replication_flags_; +} +inline void Replica::set_replication_flags(::google::protobuf::uint32 value) { + set_has_replication_flags(); + replication_flags_ = value; +} + +// required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3; +inline bool Replica::has_striping_policy() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Replica::set_has_striping_policy() { + _has_bits_[0] |= 0x00000004u; +} +inline void Replica::clear_has_striping_policy() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Replica::clear_striping_policy() { + if (striping_policy_ != NULL) striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear(); + clear_has_striping_policy(); +} +inline const ::xtreemfs::pbrpc::StripingPolicy& Replica::striping_policy() const { + return striping_policy_ != NULL ? *striping_policy_ : *default_instance_->striping_policy_; +} +inline ::xtreemfs::pbrpc::StripingPolicy* Replica::mutable_striping_policy() { + set_has_striping_policy(); + if (striping_policy_ == NULL) striping_policy_ = new ::xtreemfs::pbrpc::StripingPolicy; + return striping_policy_; +} +inline ::xtreemfs::pbrpc::StripingPolicy* Replica::release_striping_policy() { + clear_has_striping_policy(); + ::xtreemfs::pbrpc::StripingPolicy* temp = striping_policy_; + striping_policy_ = NULL; + return temp; +} +inline void Replica::set_allocated_striping_policy(::xtreemfs::pbrpc::StripingPolicy* striping_policy) { + delete striping_policy_; + striping_policy_ = striping_policy; + if (striping_policy) { + set_has_striping_policy(); + } else { + clear_has_striping_policy(); + } +} + +// ------------------------------------------------------------------- + +// Replicas + +// repeated .xtreemfs.pbrpc.Replica replicas = 1; +inline int Replicas::replicas_size() const { + return replicas_.size(); +} +inline void Replicas::clear_replicas() { + replicas_.Clear(); +} +inline const ::xtreemfs::pbrpc::Replica& Replicas::replicas(int index) const { + return replicas_.Get(index); +} +inline ::xtreemfs::pbrpc::Replica* Replicas::mutable_replicas(int index) { + return replicas_.Mutable(index); +} +inline ::xtreemfs::pbrpc::Replica* Replicas::add_replicas() { + return replicas_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica >& +Replicas::replicas() const { + return replicas_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica >* +Replicas::mutable_replicas() { + return &replicas_; +} + +// ------------------------------------------------------------------- + +// XCap + +// required fixed32 access_mode = 1; +inline bool XCap::has_access_mode() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void XCap::set_has_access_mode() { + _has_bits_[0] |= 0x00000001u; +} +inline void XCap::clear_has_access_mode() { + _has_bits_[0] &= ~0x00000001u; +} +inline void XCap::clear_access_mode() { + access_mode_ = 0u; + clear_has_access_mode(); +} +inline ::google::protobuf::uint32 XCap::access_mode() const { + return access_mode_; +} +inline void XCap::set_access_mode(::google::protobuf::uint32 value) { + set_has_access_mode(); + access_mode_ = value; +} + +// required string client_identity = 2; +inline bool XCap::has_client_identity() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void XCap::set_has_client_identity() { + _has_bits_[0] |= 0x00000002u; +} +inline void XCap::clear_has_client_identity() { + _has_bits_[0] &= ~0x00000002u; +} +inline void XCap::clear_client_identity() { + if (client_identity_ != &::google::protobuf::internal::kEmptyString) { + client_identity_->clear(); + } + clear_has_client_identity(); +} +inline const ::std::string& XCap::client_identity() const { + return *client_identity_; +} +inline void XCap::set_client_identity(const ::std::string& value) { + set_has_client_identity(); + if (client_identity_ == &::google::protobuf::internal::kEmptyString) { + client_identity_ = new ::std::string; + } + client_identity_->assign(value); +} +inline void XCap::set_client_identity(const char* value) { + set_has_client_identity(); + if (client_identity_ == &::google::protobuf::internal::kEmptyString) { + client_identity_ = new ::std::string; + } + client_identity_->assign(value); +} +inline void XCap::set_client_identity(const char* value, size_t size) { + set_has_client_identity(); + if (client_identity_ == &::google::protobuf::internal::kEmptyString) { + client_identity_ = new ::std::string; + } + client_identity_->assign(reinterpret_cast(value), size); +} +inline ::std::string* XCap::mutable_client_identity() { + set_has_client_identity(); + if (client_identity_ == &::google::protobuf::internal::kEmptyString) { + client_identity_ = new ::std::string; + } + return client_identity_; +} +inline ::std::string* XCap::release_client_identity() { + clear_has_client_identity(); + if (client_identity_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = client_identity_; + client_identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void XCap::set_allocated_client_identity(::std::string* client_identity) { + if (client_identity_ != &::google::protobuf::internal::kEmptyString) { + delete client_identity_; + } + if (client_identity) { + set_has_client_identity(); + client_identity_ = client_identity; + } else { + clear_has_client_identity(); + client_identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 expire_time_s = 3; +inline bool XCap::has_expire_time_s() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void XCap::set_has_expire_time_s() { + _has_bits_[0] |= 0x00000004u; +} +inline void XCap::clear_has_expire_time_s() { + _has_bits_[0] &= ~0x00000004u; +} +inline void XCap::clear_expire_time_s() { + expire_time_s_ = GOOGLE_ULONGLONG(0); + clear_has_expire_time_s(); +} +inline ::google::protobuf::uint64 XCap::expire_time_s() const { + return expire_time_s_; +} +inline void XCap::set_expire_time_s(::google::protobuf::uint64 value) { + set_has_expire_time_s(); + expire_time_s_ = value; +} + +// required fixed32 expire_timeout_s = 4; +inline bool XCap::has_expire_timeout_s() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void XCap::set_has_expire_timeout_s() { + _has_bits_[0] |= 0x00000008u; +} +inline void XCap::clear_has_expire_timeout_s() { + _has_bits_[0] &= ~0x00000008u; +} +inline void XCap::clear_expire_timeout_s() { + expire_timeout_s_ = 0u; + clear_has_expire_timeout_s(); +} +inline ::google::protobuf::uint32 XCap::expire_timeout_s() const { + return expire_timeout_s_; +} +inline void XCap::set_expire_timeout_s(::google::protobuf::uint32 value) { + set_has_expire_timeout_s(); + expire_timeout_s_ = value; +} + +// required string file_id = 5; +inline bool XCap::has_file_id() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void XCap::set_has_file_id() { + _has_bits_[0] |= 0x00000010u; +} +inline void XCap::clear_has_file_id() { + _has_bits_[0] &= ~0x00000010u; +} +inline void XCap::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& XCap::file_id() const { + return *file_id_; +} +inline void XCap::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void XCap::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void XCap::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* XCap::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* XCap::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void XCap::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required bool replicate_on_close = 6; +inline bool XCap::has_replicate_on_close() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void XCap::set_has_replicate_on_close() { + _has_bits_[0] |= 0x00000020u; +} +inline void XCap::clear_has_replicate_on_close() { + _has_bits_[0] &= ~0x00000020u; +} +inline void XCap::clear_replicate_on_close() { + replicate_on_close_ = false; + clear_has_replicate_on_close(); +} +inline bool XCap::replicate_on_close() const { + return replicate_on_close_; +} +inline void XCap::set_replicate_on_close(bool value) { + set_has_replicate_on_close(); + replicate_on_close_ = value; +} + +// required string server_signature = 7; +inline bool XCap::has_server_signature() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void XCap::set_has_server_signature() { + _has_bits_[0] |= 0x00000040u; +} +inline void XCap::clear_has_server_signature() { + _has_bits_[0] &= ~0x00000040u; +} +inline void XCap::clear_server_signature() { + if (server_signature_ != &::google::protobuf::internal::kEmptyString) { + server_signature_->clear(); + } + clear_has_server_signature(); +} +inline const ::std::string& XCap::server_signature() const { + return *server_signature_; +} +inline void XCap::set_server_signature(const ::std::string& value) { + set_has_server_signature(); + if (server_signature_ == &::google::protobuf::internal::kEmptyString) { + server_signature_ = new ::std::string; + } + server_signature_->assign(value); +} +inline void XCap::set_server_signature(const char* value) { + set_has_server_signature(); + if (server_signature_ == &::google::protobuf::internal::kEmptyString) { + server_signature_ = new ::std::string; + } + server_signature_->assign(value); +} +inline void XCap::set_server_signature(const char* value, size_t size) { + set_has_server_signature(); + if (server_signature_ == &::google::protobuf::internal::kEmptyString) { + server_signature_ = new ::std::string; + } + server_signature_->assign(reinterpret_cast(value), size); +} +inline ::std::string* XCap::mutable_server_signature() { + set_has_server_signature(); + if (server_signature_ == &::google::protobuf::internal::kEmptyString) { + server_signature_ = new ::std::string; + } + return server_signature_; +} +inline ::std::string* XCap::release_server_signature() { + clear_has_server_signature(); + if (server_signature_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = server_signature_; + server_signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void XCap::set_allocated_server_signature(::std::string* server_signature) { + if (server_signature_ != &::google::protobuf::internal::kEmptyString) { + delete server_signature_; + } + if (server_signature) { + set_has_server_signature(); + server_signature_ = server_signature; + } else { + clear_has_server_signature(); + server_signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 truncate_epoch = 8; +inline bool XCap::has_truncate_epoch() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void XCap::set_has_truncate_epoch() { + _has_bits_[0] |= 0x00000080u; +} +inline void XCap::clear_has_truncate_epoch() { + _has_bits_[0] &= ~0x00000080u; +} +inline void XCap::clear_truncate_epoch() { + truncate_epoch_ = 0u; + clear_has_truncate_epoch(); +} +inline ::google::protobuf::uint32 XCap::truncate_epoch() const { + return truncate_epoch_; +} +inline void XCap::set_truncate_epoch(::google::protobuf::uint32 value) { + set_has_truncate_epoch(); + truncate_epoch_ = value; +} + +// required .xtreemfs.pbrpc.SnapConfig snap_config = 9; +inline bool XCap::has_snap_config() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void XCap::set_has_snap_config() { + _has_bits_[0] |= 0x00000100u; +} +inline void XCap::clear_has_snap_config() { + _has_bits_[0] &= ~0x00000100u; +} +inline void XCap::clear_snap_config() { + snap_config_ = 0; + clear_has_snap_config(); +} +inline ::xtreemfs::pbrpc::SnapConfig XCap::snap_config() const { + return static_cast< ::xtreemfs::pbrpc::SnapConfig >(snap_config_); +} +inline void XCap::set_snap_config(::xtreemfs::pbrpc::SnapConfig value) { + assert(::xtreemfs::pbrpc::SnapConfig_IsValid(value)); + set_has_snap_config(); + snap_config_ = value; +} + +// required fixed64 snap_timestamp = 10; +inline bool XCap::has_snap_timestamp() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void XCap::set_has_snap_timestamp() { + _has_bits_[0] |= 0x00000200u; +} +inline void XCap::clear_has_snap_timestamp() { + _has_bits_[0] &= ~0x00000200u; +} +inline void XCap::clear_snap_timestamp() { + snap_timestamp_ = GOOGLE_ULONGLONG(0); + clear_has_snap_timestamp(); +} +inline ::google::protobuf::uint64 XCap::snap_timestamp() const { + return snap_timestamp_; +} +inline void XCap::set_snap_timestamp(::google::protobuf::uint64 value) { + set_has_snap_timestamp(); + snap_timestamp_ = value; +} + +// ------------------------------------------------------------------- + +// XLocSet + +// required fixed64 read_only_file_size = 1; +inline bool XLocSet::has_read_only_file_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void XLocSet::set_has_read_only_file_size() { + _has_bits_[0] |= 0x00000001u; +} +inline void XLocSet::clear_has_read_only_file_size() { + _has_bits_[0] &= ~0x00000001u; +} +inline void XLocSet::clear_read_only_file_size() { + read_only_file_size_ = GOOGLE_ULONGLONG(0); + clear_has_read_only_file_size(); +} +inline ::google::protobuf::uint64 XLocSet::read_only_file_size() const { + return read_only_file_size_; +} +inline void XLocSet::set_read_only_file_size(::google::protobuf::uint64 value) { + set_has_read_only_file_size(); + read_only_file_size_ = value; +} + +// repeated .xtreemfs.pbrpc.Replica replicas = 2; +inline int XLocSet::replicas_size() const { + return replicas_.size(); +} +inline void XLocSet::clear_replicas() { + replicas_.Clear(); +} +inline const ::xtreemfs::pbrpc::Replica& XLocSet::replicas(int index) const { + return replicas_.Get(index); +} +inline ::xtreemfs::pbrpc::Replica* XLocSet::mutable_replicas(int index) { + return replicas_.Mutable(index); +} +inline ::xtreemfs::pbrpc::Replica* XLocSet::add_replicas() { + return replicas_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica >& +XLocSet::replicas() const { + return replicas_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica >* +XLocSet::mutable_replicas() { + return &replicas_; +} + +// required string replica_update_policy = 3; +inline bool XLocSet::has_replica_update_policy() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void XLocSet::set_has_replica_update_policy() { + _has_bits_[0] |= 0x00000004u; +} +inline void XLocSet::clear_has_replica_update_policy() { + _has_bits_[0] &= ~0x00000004u; +} +inline void XLocSet::clear_replica_update_policy() { + if (replica_update_policy_ != &::google::protobuf::internal::kEmptyString) { + replica_update_policy_->clear(); + } + clear_has_replica_update_policy(); +} +inline const ::std::string& XLocSet::replica_update_policy() const { + return *replica_update_policy_; +} +inline void XLocSet::set_replica_update_policy(const ::std::string& value) { + set_has_replica_update_policy(); + if (replica_update_policy_ == &::google::protobuf::internal::kEmptyString) { + replica_update_policy_ = new ::std::string; + } + replica_update_policy_->assign(value); +} +inline void XLocSet::set_replica_update_policy(const char* value) { + set_has_replica_update_policy(); + if (replica_update_policy_ == &::google::protobuf::internal::kEmptyString) { + replica_update_policy_ = new ::std::string; + } + replica_update_policy_->assign(value); +} +inline void XLocSet::set_replica_update_policy(const char* value, size_t size) { + set_has_replica_update_policy(); + if (replica_update_policy_ == &::google::protobuf::internal::kEmptyString) { + replica_update_policy_ = new ::std::string; + } + replica_update_policy_->assign(reinterpret_cast(value), size); +} +inline ::std::string* XLocSet::mutable_replica_update_policy() { + set_has_replica_update_policy(); + if (replica_update_policy_ == &::google::protobuf::internal::kEmptyString) { + replica_update_policy_ = new ::std::string; + } + return replica_update_policy_; +} +inline ::std::string* XLocSet::release_replica_update_policy() { + clear_has_replica_update_policy(); + if (replica_update_policy_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = replica_update_policy_; + replica_update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void XLocSet::set_allocated_replica_update_policy(::std::string* replica_update_policy) { + if (replica_update_policy_ != &::google::protobuf::internal::kEmptyString) { + delete replica_update_policy_; + } + if (replica_update_policy) { + set_has_replica_update_policy(); + replica_update_policy_ = replica_update_policy; + } else { + clear_has_replica_update_policy(); + replica_update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 version = 4; +inline bool XLocSet::has_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void XLocSet::set_has_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void XLocSet::clear_has_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void XLocSet::clear_version() { + version_ = 0u; + clear_has_version(); +} +inline ::google::protobuf::uint32 XLocSet::version() const { + return version_; +} +inline void XLocSet::set_version(::google::protobuf::uint32 value) { + set_has_version(); + version_ = value; +} + +// ------------------------------------------------------------------- + +// FileCredentials + +// required .xtreemfs.pbrpc.XCap xcap = 1; +inline bool FileCredentials::has_xcap() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FileCredentials::set_has_xcap() { + _has_bits_[0] |= 0x00000001u; +} +inline void FileCredentials::clear_has_xcap() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FileCredentials::clear_xcap() { + if (xcap_ != NULL) xcap_->::xtreemfs::pbrpc::XCap::Clear(); + clear_has_xcap(); +} +inline const ::xtreemfs::pbrpc::XCap& FileCredentials::xcap() const { + return xcap_ != NULL ? *xcap_ : *default_instance_->xcap_; +} +inline ::xtreemfs::pbrpc::XCap* FileCredentials::mutable_xcap() { + set_has_xcap(); + if (xcap_ == NULL) xcap_ = new ::xtreemfs::pbrpc::XCap; + return xcap_; +} +inline ::xtreemfs::pbrpc::XCap* FileCredentials::release_xcap() { + clear_has_xcap(); + ::xtreemfs::pbrpc::XCap* temp = xcap_; + xcap_ = NULL; + return temp; +} +inline void FileCredentials::set_allocated_xcap(::xtreemfs::pbrpc::XCap* xcap) { + delete xcap_; + xcap_ = xcap; + if (xcap) { + set_has_xcap(); + } else { + clear_has_xcap(); + } +} + +// required .xtreemfs.pbrpc.XLocSet xlocs = 2; +inline bool FileCredentials::has_xlocs() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void FileCredentials::set_has_xlocs() { + _has_bits_[0] |= 0x00000002u; +} +inline void FileCredentials::clear_has_xlocs() { + _has_bits_[0] &= ~0x00000002u; +} +inline void FileCredentials::clear_xlocs() { + if (xlocs_ != NULL) xlocs_->::xtreemfs::pbrpc::XLocSet::Clear(); + clear_has_xlocs(); +} +inline const ::xtreemfs::pbrpc::XLocSet& FileCredentials::xlocs() const { + return xlocs_ != NULL ? *xlocs_ : *default_instance_->xlocs_; +} +inline ::xtreemfs::pbrpc::XLocSet* FileCredentials::mutable_xlocs() { + set_has_xlocs(); + if (xlocs_ == NULL) xlocs_ = new ::xtreemfs::pbrpc::XLocSet; + return xlocs_; +} +inline ::xtreemfs::pbrpc::XLocSet* FileCredentials::release_xlocs() { + clear_has_xlocs(); + ::xtreemfs::pbrpc::XLocSet* temp = xlocs_; + xlocs_ = NULL; + return temp; +} +inline void FileCredentials::set_allocated_xlocs(::xtreemfs::pbrpc::XLocSet* xlocs) { + delete xlocs_; + xlocs_ = xlocs; + if (xlocs) { + set_has_xlocs(); + } else { + clear_has_xlocs(); + } +} + +// ------------------------------------------------------------------- + +// FileCredentialsSet + +// optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool FileCredentialsSet::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void FileCredentialsSet::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void FileCredentialsSet::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void FileCredentialsSet::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& FileCredentialsSet::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* FileCredentialsSet::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* FileCredentialsSet::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void FileCredentialsSet::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// ------------------------------------------------------------------- + +// VivaldiCoordinates + +// required double x_coordinate = 1; +inline bool VivaldiCoordinates::has_x_coordinate() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void VivaldiCoordinates::set_has_x_coordinate() { + _has_bits_[0] |= 0x00000001u; +} +inline void VivaldiCoordinates::clear_has_x_coordinate() { + _has_bits_[0] &= ~0x00000001u; +} +inline void VivaldiCoordinates::clear_x_coordinate() { + x_coordinate_ = 0; + clear_has_x_coordinate(); +} +inline double VivaldiCoordinates::x_coordinate() const { + return x_coordinate_; +} +inline void VivaldiCoordinates::set_x_coordinate(double value) { + set_has_x_coordinate(); + x_coordinate_ = value; +} + +// required double y_coordinate = 2; +inline bool VivaldiCoordinates::has_y_coordinate() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void VivaldiCoordinates::set_has_y_coordinate() { + _has_bits_[0] |= 0x00000002u; +} +inline void VivaldiCoordinates::clear_has_y_coordinate() { + _has_bits_[0] &= ~0x00000002u; +} +inline void VivaldiCoordinates::clear_y_coordinate() { + y_coordinate_ = 0; + clear_has_y_coordinate(); +} +inline double VivaldiCoordinates::y_coordinate() const { + return y_coordinate_; +} +inline void VivaldiCoordinates::set_y_coordinate(double value) { + set_has_y_coordinate(); + y_coordinate_ = value; +} + +// required double local_error = 3; +inline bool VivaldiCoordinates::has_local_error() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void VivaldiCoordinates::set_has_local_error() { + _has_bits_[0] |= 0x00000004u; +} +inline void VivaldiCoordinates::clear_has_local_error() { + _has_bits_[0] &= ~0x00000004u; +} +inline void VivaldiCoordinates::clear_local_error() { + local_error_ = 0; + clear_has_local_error(); +} +inline double VivaldiCoordinates::local_error() const { + return local_error_; +} +inline void VivaldiCoordinates::set_local_error(double value) { + set_has_local_error(); + local_error_ = value; +} + +// ------------------------------------------------------------------- + +// OSDWriteResponse + +// optional fixed64 size_in_bytes = 1; +inline bool OSDWriteResponse::has_size_in_bytes() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void OSDWriteResponse::set_has_size_in_bytes() { + _has_bits_[0] |= 0x00000001u; +} +inline void OSDWriteResponse::clear_has_size_in_bytes() { + _has_bits_[0] &= ~0x00000001u; +} +inline void OSDWriteResponse::clear_size_in_bytes() { + size_in_bytes_ = GOOGLE_ULONGLONG(0); + clear_has_size_in_bytes(); +} +inline ::google::protobuf::uint64 OSDWriteResponse::size_in_bytes() const { + return size_in_bytes_; +} +inline void OSDWriteResponse::set_size_in_bytes(::google::protobuf::uint64 value) { + set_has_size_in_bytes(); + size_in_bytes_ = value; +} + +// optional fixed32 truncate_epoch = 2; +inline bool OSDWriteResponse::has_truncate_epoch() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void OSDWriteResponse::set_has_truncate_epoch() { + _has_bits_[0] |= 0x00000002u; +} +inline void OSDWriteResponse::clear_has_truncate_epoch() { + _has_bits_[0] &= ~0x00000002u; +} +inline void OSDWriteResponse::clear_truncate_epoch() { + truncate_epoch_ = 0u; + clear_has_truncate_epoch(); +} +inline ::google::protobuf::uint32 OSDWriteResponse::truncate_epoch() const { + return truncate_epoch_; +} +inline void OSDWriteResponse::set_truncate_epoch(::google::protobuf::uint32 value) { + set_has_truncate_epoch(); + truncate_epoch_ = value; +} + +// ------------------------------------------------------------------- + +// KeyValuePair + +// required string key = 1; +inline bool KeyValuePair::has_key() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void KeyValuePair::set_has_key() { + _has_bits_[0] |= 0x00000001u; +} +inline void KeyValuePair::clear_has_key() { + _has_bits_[0] &= ~0x00000001u; +} +inline void KeyValuePair::clear_key() { + if (key_ != &::google::protobuf::internal::kEmptyString) { + key_->clear(); + } + clear_has_key(); +} +inline const ::std::string& KeyValuePair::key() const { + return *key_; +} +inline void KeyValuePair::set_key(const ::std::string& value) { + set_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + key_ = new ::std::string; + } + key_->assign(value); +} +inline void KeyValuePair::set_key(const char* value) { + set_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + key_ = new ::std::string; + } + key_->assign(value); +} +inline void KeyValuePair::set_key(const char* value, size_t size) { + set_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + key_ = new ::std::string; + } + key_->assign(reinterpret_cast(value), size); +} +inline ::std::string* KeyValuePair::mutable_key() { + set_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + key_ = new ::std::string; + } + return key_; +} +inline ::std::string* KeyValuePair::release_key() { + clear_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = key_; + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void KeyValuePair::set_allocated_key(::std::string* key) { + if (key_ != &::google::protobuf::internal::kEmptyString) { + delete key_; + } + if (key) { + set_has_key(); + key_ = key; + } else { + clear_has_key(); + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string value = 2; +inline bool KeyValuePair::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void KeyValuePair::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void KeyValuePair::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void KeyValuePair::clear_value() { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + clear_has_value(); +} +inline const ::std::string& KeyValuePair::value() const { + return *value_; +} +inline void KeyValuePair::set_value(const ::std::string& value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void KeyValuePair::set_value(const char* value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void KeyValuePair::set_value(const char* value, size_t size) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(reinterpret_cast(value), size); +} +inline ::std::string* KeyValuePair::mutable_value() { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + return value_; +} +inline ::std::string* KeyValuePair::release_value() { + clear_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = value_; + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void KeyValuePair::set_allocated_value(::std::string* value) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (value) { + set_has_value(); + value_ = value; + } else { + clear_has_value(); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::AccessControlPolicyType>() { + return ::xtreemfs::pbrpc::AccessControlPolicyType_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::OSDSelectionPolicyType>() { + return ::xtreemfs::pbrpc::OSDSelectionPolicyType_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::ReplicaSelectionPolicyType>() { + return ::xtreemfs::pbrpc::ReplicaSelectionPolicyType_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::SnapConfig>() { + return ::xtreemfs::pbrpc::SnapConfig_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::StripingPolicyType>() { + return ::xtreemfs::pbrpc::StripingPolicyType_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::LeaseState>() { + return ::xtreemfs::pbrpc::LeaseState_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::PORTS>() { + return ::xtreemfs::pbrpc::PORTS_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::CONSTANTS>() { + return ::xtreemfs::pbrpc::CONSTANTS_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::SYSTEM_V_FCNTL>() { + return ::xtreemfs::pbrpc::SYSTEM_V_FCNTL_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::REPL_FLAG>() { + return ::xtreemfs::pbrpc::REPL_FLAG_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::SERVICES>() { + return ::xtreemfs::pbrpc::SERVICES_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_xtreemfs_2fGlobalTypes_2eproto__INCLUDED diff --git a/cpp/generated/xtreemfs/MRC.pb.cc b/cpp/generated/xtreemfs/MRC.pb.cc new file mode 100644 index 0000000..6a9898f --- /dev/null +++ b/cpp/generated/xtreemfs/MRC.pb.cc @@ -0,0 +1,18740 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: xtreemfs/MRC.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "xtreemfs/MRC.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +namespace { + +const ::google::protobuf::Descriptor* Stat_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Stat_reflection_ = NULL; +const ::google::protobuf::Descriptor* DirectoryEntry_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DirectoryEntry_reflection_ = NULL; +const ::google::protobuf::Descriptor* DirectoryEntries_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + DirectoryEntries_reflection_ = NULL; +const ::google::protobuf::Descriptor* XAttr_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + XAttr_reflection_ = NULL; +const ::google::protobuf::Descriptor* Volume_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Volume_reflection_ = NULL; +const ::google::protobuf::Descriptor* Volumes_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Volumes_reflection_ = NULL; +const ::google::protobuf::Descriptor* StatVFS_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + StatVFS_reflection_ = NULL; +const ::google::protobuf::Descriptor* fsetattrRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + fsetattrRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* getattrRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + getattrRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* getattrResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + getattrResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* getxattrRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + getxattrRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* getxattrResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + getxattrResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* linkRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + linkRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* listxattrRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + listxattrRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* listxattrResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + listxattrResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* mkdirRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + mkdirRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* openRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + openRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* openResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + openResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* readdirRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + readdirRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* readlinkRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + readlinkRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* readlinkResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + readlinkResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* removexattrRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + removexattrRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* renameRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + renameRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* renameResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + renameResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* rmdirRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + rmdirRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* setattrRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + setattrRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* setxattrRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + setxattrRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* statvfsRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + statvfsRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* symlinkRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + symlinkRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* unlinkRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + unlinkRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* unlinkResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + unlinkResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* accessRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + accessRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_check_file_existsRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_check_file_existsRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_check_file_existsResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_check_file_existsResponse_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* xtreemfs_check_file_existsResponse_FILE_STATE_descriptor_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_dump_restore_databaseRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_dump_restore_databaseRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_get_suitable_osdsRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_get_suitable_osdsRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_get_suitable_osdsResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_get_suitable_osdsResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* timestampResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + timestampResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* stringMessage_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + stringMessage_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_listdirRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_listdirRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_listdirResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_listdirResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_replica_addRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_replica_addRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_replica_listRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_replica_listRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_get_xlocsetRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_get_xlocsetRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_replica_removeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_replica_removeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_restore_fileRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_restore_fileRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rmvolRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rmvolRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_update_file_sizeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_update_file_sizeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_set_replica_update_policyRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_set_replica_update_policyRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_set_replica_update_policyResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_set_replica_update_policyResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_set_read_only_xattrRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_set_read_only_xattrRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_set_read_only_xattrResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_set_read_only_xattrResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_get_file_credentialsRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_get_file_credentialsRequest_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* Setattrs_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* XATTR_FLAGS_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* ACCESS_FLAGS_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto() { + protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "xtreemfs/MRC.proto"); + GOOGLE_CHECK(file != NULL); + Stat_descriptor_ = file->message_type(0); + static const int Stat_offsets_[14] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, dev_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, ino_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, nlink_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, user_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, group_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, atime_ns_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, mtime_ns_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, ctime_ns_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, blksize_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, etag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, truncate_epoch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, attributes_), + }; + Stat_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Stat_descriptor_, + Stat::default_instance_, + Stat_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stat, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Stat)); + DirectoryEntry_descriptor_ = file->message_type(1); + static const int DirectoryEntry_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirectoryEntry, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirectoryEntry, stbuf_), + }; + DirectoryEntry_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + DirectoryEntry_descriptor_, + DirectoryEntry::default_instance_, + DirectoryEntry_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirectoryEntry, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirectoryEntry, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(DirectoryEntry)); + DirectoryEntries_descriptor_ = file->message_type(2); + static const int DirectoryEntries_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirectoryEntries, entries_), + }; + DirectoryEntries_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + DirectoryEntries_descriptor_, + DirectoryEntries::default_instance_, + DirectoryEntries_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirectoryEntries, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirectoryEntries, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(DirectoryEntries)); + XAttr_descriptor_ = file->message_type(3); + static const int XAttr_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XAttr, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XAttr, value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XAttr, value_bytes_string_), + }; + XAttr_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + XAttr_descriptor_, + XAttr::default_instance_, + XAttr_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XAttr, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XAttr, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(XAttr)); + Volume_descriptor_ = file->message_type(4); + static const int Volume_offsets_[9] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, access_control_policy_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, default_striping_policy_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, owner_group_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, owner_user_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, attrs_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, quota_), + }; + Volume_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Volume_descriptor_, + Volume::default_instance_, + Volume_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volume, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Volume)); + Volumes_descriptor_ = file->message_type(5); + static const int Volumes_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volumes, volumes_), + }; + Volumes_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Volumes_descriptor_, + Volumes::default_instance_, + Volumes_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volumes, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Volumes, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Volumes)); + StatVFS_descriptor_ = file->message_type(6); + static const int StatVFS_offsets_[13] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, bsize_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, bavail_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, bfree_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, blocks_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, fsid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, namemax_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, access_control_policy_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, default_striping_policy_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, etag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, owner_group_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, owner_user_id_), + }; + StatVFS_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + StatVFS_descriptor_, + StatVFS::default_instance_, + StatVFS_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatVFS, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(StatVFS)); + fsetattrRequest_descriptor_ = file->message_type(7); + static const int fsetattrRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(fsetattrRequest, stbuf_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(fsetattrRequest, to_set_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(fsetattrRequest, cap_), + }; + fsetattrRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + fsetattrRequest_descriptor_, + fsetattrRequest::default_instance_, + fsetattrRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(fsetattrRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(fsetattrRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(fsetattrRequest)); + getattrRequest_descriptor_ = file->message_type(8); + static const int getattrRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getattrRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getattrRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getattrRequest, known_etag_), + }; + getattrRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + getattrRequest_descriptor_, + getattrRequest::default_instance_, + getattrRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getattrRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getattrRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(getattrRequest)); + getattrResponse_descriptor_ = file->message_type(9); + static const int getattrResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getattrResponse, stbuf_), + }; + getattrResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + getattrResponse_descriptor_, + getattrResponse::default_instance_, + getattrResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getattrResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getattrResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(getattrResponse)); + getxattrRequest_descriptor_ = file->message_type(10); + static const int getxattrRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrRequest, name_), + }; + getxattrRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + getxattrRequest_descriptor_, + getxattrRequest::default_instance_, + getxattrRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(getxattrRequest)); + getxattrResponse_descriptor_ = file->message_type(11); + static const int getxattrResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrResponse, value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrResponse, value_bytes_string_), + }; + getxattrResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + getxattrResponse_descriptor_, + getxattrResponse::default_instance_, + getxattrResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(getxattrResponse)); + linkRequest_descriptor_ = file->message_type(12); + static const int linkRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(linkRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(linkRequest, target_path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(linkRequest, link_path_), + }; + linkRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + linkRequest_descriptor_, + linkRequest::default_instance_, + linkRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(linkRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(linkRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(linkRequest)); + listxattrRequest_descriptor_ = file->message_type(13); + static const int listxattrRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(listxattrRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(listxattrRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(listxattrRequest, names_only_), + }; + listxattrRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + listxattrRequest_descriptor_, + listxattrRequest::default_instance_, + listxattrRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(listxattrRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(listxattrRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(listxattrRequest)); + listxattrResponse_descriptor_ = file->message_type(14); + static const int listxattrResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(listxattrResponse, xattrs_), + }; + listxattrResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + listxattrResponse_descriptor_, + listxattrResponse::default_instance_, + listxattrResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(listxattrResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(listxattrResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(listxattrResponse)); + mkdirRequest_descriptor_ = file->message_type(15); + static const int mkdirRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(mkdirRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(mkdirRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(mkdirRequest, mode_), + }; + mkdirRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + mkdirRequest_descriptor_, + mkdirRequest::default_instance_, + mkdirRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(mkdirRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(mkdirRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(mkdirRequest)); + openRequest_descriptor_ = file->message_type(16); + static const int openRequest_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openRequest, flags_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openRequest, mode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openRequest, attributes_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openRequest, coordinates_), + }; + openRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + openRequest_descriptor_, + openRequest::default_instance_, + openRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(openRequest)); + openResponse_descriptor_ = file->message_type(17); + static const int openResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openResponse, creds_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openResponse, timestamp_s_), + }; + openResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + openResponse_descriptor_, + openResponse::default_instance_, + openResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(openResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(openResponse)); + readdirRequest_descriptor_ = file->message_type(18); + static const int readdirRequest_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readdirRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readdirRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readdirRequest, known_etag_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readdirRequest, limit_directory_entries_count_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readdirRequest, names_only_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readdirRequest, seen_directory_entries_count_), + }; + readdirRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + readdirRequest_descriptor_, + readdirRequest::default_instance_, + readdirRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readdirRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readdirRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(readdirRequest)); + readlinkRequest_descriptor_ = file->message_type(19); + static const int readlinkRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readlinkRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readlinkRequest, path_), + }; + readlinkRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + readlinkRequest_descriptor_, + readlinkRequest::default_instance_, + readlinkRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readlinkRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readlinkRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(readlinkRequest)); + readlinkResponse_descriptor_ = file->message_type(20); + static const int readlinkResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readlinkResponse, link_target_path_), + }; + readlinkResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + readlinkResponse_descriptor_, + readlinkResponse::default_instance_, + readlinkResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readlinkResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readlinkResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(readlinkResponse)); + removexattrRequest_descriptor_ = file->message_type(21); + static const int removexattrRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(removexattrRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(removexattrRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(removexattrRequest, name_), + }; + removexattrRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + removexattrRequest_descriptor_, + removexattrRequest::default_instance_, + removexattrRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(removexattrRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(removexattrRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(removexattrRequest)); + renameRequest_descriptor_ = file->message_type(22); + static const int renameRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameRequest, source_path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameRequest, target_path_), + }; + renameRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + renameRequest_descriptor_, + renameRequest::default_instance_, + renameRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(renameRequest)); + renameResponse_descriptor_ = file->message_type(23); + static const int renameResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameResponse, timestamp_s_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameResponse, creds_), + }; + renameResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + renameResponse_descriptor_, + renameResponse::default_instance_, + renameResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(renameResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(renameResponse)); + rmdirRequest_descriptor_ = file->message_type(24); + static const int rmdirRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(rmdirRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(rmdirRequest, path_), + }; + rmdirRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + rmdirRequest_descriptor_, + rmdirRequest::default_instance_, + rmdirRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(rmdirRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(rmdirRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(rmdirRequest)); + setattrRequest_descriptor_ = file->message_type(25); + static const int setattrRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setattrRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setattrRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setattrRequest, stbuf_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setattrRequest, to_set_), + }; + setattrRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + setattrRequest_descriptor_, + setattrRequest::default_instance_, + setattrRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setattrRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setattrRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(setattrRequest)); + setxattrRequest_descriptor_ = file->message_type(26); + static const int setxattrRequest_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, value_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, value_bytes_string_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, flags_), + }; + setxattrRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + setxattrRequest_descriptor_, + setxattrRequest::default_instance_, + setxattrRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(setxattrRequest)); + statvfsRequest_descriptor_ = file->message_type(27); + static const int statvfsRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(statvfsRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(statvfsRequest, known_etag_), + }; + statvfsRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + statvfsRequest_descriptor_, + statvfsRequest::default_instance_, + statvfsRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(statvfsRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(statvfsRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(statvfsRequest)); + symlinkRequest_descriptor_ = file->message_type(28); + static const int symlinkRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(symlinkRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(symlinkRequest, target_path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(symlinkRequest, link_path_), + }; + symlinkRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + symlinkRequest_descriptor_, + symlinkRequest::default_instance_, + symlinkRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(symlinkRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(symlinkRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(symlinkRequest)); + unlinkRequest_descriptor_ = file->message_type(29); + static const int unlinkRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlinkRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlinkRequest, path_), + }; + unlinkRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + unlinkRequest_descriptor_, + unlinkRequest::default_instance_, + unlinkRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlinkRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlinkRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(unlinkRequest)); + unlinkResponse_descriptor_ = file->message_type(30); + static const int unlinkResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlinkResponse, timestamp_s_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlinkResponse, creds_), + }; + unlinkResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + unlinkResponse_descriptor_, + unlinkResponse::default_instance_, + unlinkResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlinkResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlinkResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(unlinkResponse)); + accessRequest_descriptor_ = file->message_type(31); + static const int accessRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(accessRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(accessRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(accessRequest, flags_), + }; + accessRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + accessRequest_descriptor_, + accessRequest::default_instance_, + accessRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(accessRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(accessRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(accessRequest)); + xtreemfs_check_file_existsRequest_descriptor_ = file->message_type(32); + static const int xtreemfs_check_file_existsRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsRequest, volume_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsRequest, file_ids_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsRequest, osd_uuid_), + }; + xtreemfs_check_file_existsRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_check_file_existsRequest_descriptor_, + xtreemfs_check_file_existsRequest::default_instance_, + xtreemfs_check_file_existsRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_check_file_existsRequest)); + xtreemfs_check_file_existsResponse_descriptor_ = file->message_type(33); + static const int xtreemfs_check_file_existsResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsResponse, volume_exists_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsResponse, file_states_), + }; + xtreemfs_check_file_existsResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_check_file_existsResponse_descriptor_, + xtreemfs_check_file_existsResponse::default_instance_, + xtreemfs_check_file_existsResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_file_existsResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_check_file_existsResponse)); + xtreemfs_check_file_existsResponse_FILE_STATE_descriptor_ = xtreemfs_check_file_existsResponse_descriptor_->enum_type(0); + xtreemfs_dump_restore_databaseRequest_descriptor_ = file->message_type(34); + static const int xtreemfs_dump_restore_databaseRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_dump_restore_databaseRequest, dump_file_), + }; + xtreemfs_dump_restore_databaseRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_dump_restore_databaseRequest_descriptor_, + xtreemfs_dump_restore_databaseRequest::default_instance_, + xtreemfs_dump_restore_databaseRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_dump_restore_databaseRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_dump_restore_databaseRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_dump_restore_databaseRequest)); + xtreemfs_get_suitable_osdsRequest_descriptor_ = file->message_type(35); + static const int xtreemfs_get_suitable_osdsRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsRequest, num_osds_), + }; + xtreemfs_get_suitable_osdsRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_get_suitable_osdsRequest_descriptor_, + xtreemfs_get_suitable_osdsRequest::default_instance_, + xtreemfs_get_suitable_osdsRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_get_suitable_osdsRequest)); + xtreemfs_get_suitable_osdsResponse_descriptor_ = file->message_type(36); + static const int xtreemfs_get_suitable_osdsResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsResponse, osd_uuids_), + }; + xtreemfs_get_suitable_osdsResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_get_suitable_osdsResponse_descriptor_, + xtreemfs_get_suitable_osdsResponse::default_instance_, + xtreemfs_get_suitable_osdsResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_suitable_osdsResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_get_suitable_osdsResponse)); + timestampResponse_descriptor_ = file->message_type(37); + static const int timestampResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(timestampResponse, timestamp_s_), + }; + timestampResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + timestampResponse_descriptor_, + timestampResponse::default_instance_, + timestampResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(timestampResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(timestampResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(timestampResponse)); + stringMessage_descriptor_ = file->message_type(38); + static const int stringMessage_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(stringMessage, a_string_), + }; + stringMessage_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + stringMessage_descriptor_, + stringMessage::default_instance_, + stringMessage_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(stringMessage, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(stringMessage, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(stringMessage)); + xtreemfs_listdirRequest_descriptor_ = file->message_type(39); + static const int xtreemfs_listdirRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_listdirRequest, path_), + }; + xtreemfs_listdirRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_listdirRequest_descriptor_, + xtreemfs_listdirRequest::default_instance_, + xtreemfs_listdirRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_listdirRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_listdirRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_listdirRequest)); + xtreemfs_listdirResponse_descriptor_ = file->message_type(40); + static const int xtreemfs_listdirResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_listdirResponse, names_), + }; + xtreemfs_listdirResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_listdirResponse_descriptor_, + xtreemfs_listdirResponse::default_instance_, + xtreemfs_listdirResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_listdirResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_listdirResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_listdirResponse)); + xtreemfs_replica_addRequest_descriptor_ = file->message_type(41); + static const int xtreemfs_replica_addRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_addRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_addRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_addRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_addRequest, new_replica_), + }; + xtreemfs_replica_addRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_replica_addRequest_descriptor_, + xtreemfs_replica_addRequest::default_instance_, + xtreemfs_replica_addRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_addRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_addRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_replica_addRequest)); + xtreemfs_replica_listRequest_descriptor_ = file->message_type(42); + static const int xtreemfs_replica_listRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_listRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_listRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_listRequest, volume_name_), + }; + xtreemfs_replica_listRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_replica_listRequest_descriptor_, + xtreemfs_replica_listRequest::default_instance_, + xtreemfs_replica_listRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_listRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_listRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_replica_listRequest)); + xtreemfs_get_xlocsetRequest_descriptor_ = file->message_type(43); + static const int xtreemfs_get_xlocsetRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_xlocsetRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_xlocsetRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_xlocsetRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_xlocsetRequest, xcap_), + }; + xtreemfs_get_xlocsetRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_get_xlocsetRequest_descriptor_, + xtreemfs_get_xlocsetRequest::default_instance_, + xtreemfs_get_xlocsetRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_xlocsetRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_xlocsetRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_get_xlocsetRequest)); + xtreemfs_replica_removeRequest_descriptor_ = file->message_type(44); + static const int xtreemfs_replica_removeRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_removeRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_removeRequest, path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_removeRequest, volume_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_removeRequest, osd_uuid_), + }; + xtreemfs_replica_removeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_replica_removeRequest_descriptor_, + xtreemfs_replica_removeRequest::default_instance_, + xtreemfs_replica_removeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_removeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_replica_removeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_replica_removeRequest)); + xtreemfs_restore_fileRequest_descriptor_ = file->message_type(45); + static const int xtreemfs_restore_fileRequest_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_restore_fileRequest, file_path_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_restore_fileRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_restore_fileRequest, file_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_restore_fileRequest, osd_uuid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_restore_fileRequest, stripe_size_), + }; + xtreemfs_restore_fileRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_restore_fileRequest_descriptor_, + xtreemfs_restore_fileRequest::default_instance_, + xtreemfs_restore_fileRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_restore_fileRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_restore_fileRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_restore_fileRequest)); + xtreemfs_rmvolRequest_descriptor_ = file->message_type(46); + static const int xtreemfs_rmvolRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rmvolRequest, volume_name_), + }; + xtreemfs_rmvolRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rmvolRequest_descriptor_, + xtreemfs_rmvolRequest::default_instance_, + xtreemfs_rmvolRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rmvolRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rmvolRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rmvolRequest)); + xtreemfs_update_file_sizeRequest_descriptor_ = file->message_type(47); + static const int xtreemfs_update_file_sizeRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_update_file_sizeRequest, xcap_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_update_file_sizeRequest, osd_write_response_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_update_file_sizeRequest, close_file_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_update_file_sizeRequest, coordinates_), + }; + xtreemfs_update_file_sizeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_update_file_sizeRequest_descriptor_, + xtreemfs_update_file_sizeRequest::default_instance_, + xtreemfs_update_file_sizeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_update_file_sizeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_update_file_sizeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_update_file_sizeRequest)); + xtreemfs_set_replica_update_policyRequest_descriptor_ = file->message_type(48); + static const int xtreemfs_set_replica_update_policyRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_replica_update_policyRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_replica_update_policyRequest, update_policy_), + }; + xtreemfs_set_replica_update_policyRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_set_replica_update_policyRequest_descriptor_, + xtreemfs_set_replica_update_policyRequest::default_instance_, + xtreemfs_set_replica_update_policyRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_replica_update_policyRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_replica_update_policyRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_set_replica_update_policyRequest)); + xtreemfs_set_replica_update_policyResponse_descriptor_ = file->message_type(49); + static const int xtreemfs_set_replica_update_policyResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_replica_update_policyResponse, old_update_policy_), + }; + xtreemfs_set_replica_update_policyResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_set_replica_update_policyResponse_descriptor_, + xtreemfs_set_replica_update_policyResponse::default_instance_, + xtreemfs_set_replica_update_policyResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_replica_update_policyResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_replica_update_policyResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_set_replica_update_policyResponse)); + xtreemfs_set_read_only_xattrRequest_descriptor_ = file->message_type(50); + static const int xtreemfs_set_read_only_xattrRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_read_only_xattrRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_read_only_xattrRequest, value_), + }; + xtreemfs_set_read_only_xattrRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_set_read_only_xattrRequest_descriptor_, + xtreemfs_set_read_only_xattrRequest::default_instance_, + xtreemfs_set_read_only_xattrRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_read_only_xattrRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_read_only_xattrRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_set_read_only_xattrRequest)); + xtreemfs_set_read_only_xattrResponse_descriptor_ = file->message_type(51); + static const int xtreemfs_set_read_only_xattrResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_read_only_xattrResponse, was_set_), + }; + xtreemfs_set_read_only_xattrResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_set_read_only_xattrResponse_descriptor_, + xtreemfs_set_read_only_xattrResponse::default_instance_, + xtreemfs_set_read_only_xattrResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_read_only_xattrResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_set_read_only_xattrResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_set_read_only_xattrResponse)); + xtreemfs_get_file_credentialsRequest_descriptor_ = file->message_type(52); + static const int xtreemfs_get_file_credentialsRequest_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_file_credentialsRequest, file_id_), + }; + xtreemfs_get_file_credentialsRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_get_file_credentialsRequest_descriptor_, + xtreemfs_get_file_credentialsRequest::default_instance_, + xtreemfs_get_file_credentialsRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_file_credentialsRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_get_file_credentialsRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_get_file_credentialsRequest)); + Setattrs_descriptor_ = file->enum_type(0); + XATTR_FLAGS_descriptor_ = file->enum_type(1); + ACCESS_FLAGS_descriptor_ = file->enum_type(2); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_xtreemfs_2fMRC_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Stat_descriptor_, &Stat::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DirectoryEntry_descriptor_, &DirectoryEntry::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + DirectoryEntries_descriptor_, &DirectoryEntries::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + XAttr_descriptor_, &XAttr::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Volume_descriptor_, &Volume::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Volumes_descriptor_, &Volumes::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + StatVFS_descriptor_, &StatVFS::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + fsetattrRequest_descriptor_, &fsetattrRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + getattrRequest_descriptor_, &getattrRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + getattrResponse_descriptor_, &getattrResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + getxattrRequest_descriptor_, &getxattrRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + getxattrResponse_descriptor_, &getxattrResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + linkRequest_descriptor_, &linkRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + listxattrRequest_descriptor_, &listxattrRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + listxattrResponse_descriptor_, &listxattrResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + mkdirRequest_descriptor_, &mkdirRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + openRequest_descriptor_, &openRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + openResponse_descriptor_, &openResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + readdirRequest_descriptor_, &readdirRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + readlinkRequest_descriptor_, &readlinkRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + readlinkResponse_descriptor_, &readlinkResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + removexattrRequest_descriptor_, &removexattrRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + renameRequest_descriptor_, &renameRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + renameResponse_descriptor_, &renameResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + rmdirRequest_descriptor_, &rmdirRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + setattrRequest_descriptor_, &setattrRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + setxattrRequest_descriptor_, &setxattrRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + statvfsRequest_descriptor_, &statvfsRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + symlinkRequest_descriptor_, &symlinkRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + unlinkRequest_descriptor_, &unlinkRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + unlinkResponse_descriptor_, &unlinkResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + accessRequest_descriptor_, &accessRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_check_file_existsRequest_descriptor_, &xtreemfs_check_file_existsRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_check_file_existsResponse_descriptor_, &xtreemfs_check_file_existsResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_dump_restore_databaseRequest_descriptor_, &xtreemfs_dump_restore_databaseRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_get_suitable_osdsRequest_descriptor_, &xtreemfs_get_suitable_osdsRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_get_suitable_osdsResponse_descriptor_, &xtreemfs_get_suitable_osdsResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + timestampResponse_descriptor_, ×tampResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + stringMessage_descriptor_, &stringMessage::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_listdirRequest_descriptor_, &xtreemfs_listdirRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_listdirResponse_descriptor_, &xtreemfs_listdirResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_replica_addRequest_descriptor_, &xtreemfs_replica_addRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_replica_listRequest_descriptor_, &xtreemfs_replica_listRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_get_xlocsetRequest_descriptor_, &xtreemfs_get_xlocsetRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_replica_removeRequest_descriptor_, &xtreemfs_replica_removeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_restore_fileRequest_descriptor_, &xtreemfs_restore_fileRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rmvolRequest_descriptor_, &xtreemfs_rmvolRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_update_file_sizeRequest_descriptor_, &xtreemfs_update_file_sizeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_set_replica_update_policyRequest_descriptor_, &xtreemfs_set_replica_update_policyRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_set_replica_update_policyResponse_descriptor_, &xtreemfs_set_replica_update_policyResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_set_read_only_xattrRequest_descriptor_, &xtreemfs_set_read_only_xattrRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_set_read_only_xattrResponse_descriptor_, &xtreemfs_set_read_only_xattrResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_get_file_credentialsRequest_descriptor_, &xtreemfs_get_file_credentialsRequest::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto() { + delete Stat::default_instance_; + delete Stat_reflection_; + delete DirectoryEntry::default_instance_; + delete DirectoryEntry_reflection_; + delete DirectoryEntries::default_instance_; + delete DirectoryEntries_reflection_; + delete XAttr::default_instance_; + delete XAttr_reflection_; + delete Volume::default_instance_; + delete Volume_reflection_; + delete Volumes::default_instance_; + delete Volumes_reflection_; + delete StatVFS::default_instance_; + delete StatVFS_reflection_; + delete fsetattrRequest::default_instance_; + delete fsetattrRequest_reflection_; + delete getattrRequest::default_instance_; + delete getattrRequest_reflection_; + delete getattrResponse::default_instance_; + delete getattrResponse_reflection_; + delete getxattrRequest::default_instance_; + delete getxattrRequest_reflection_; + delete getxattrResponse::default_instance_; + delete getxattrResponse_reflection_; + delete linkRequest::default_instance_; + delete linkRequest_reflection_; + delete listxattrRequest::default_instance_; + delete listxattrRequest_reflection_; + delete listxattrResponse::default_instance_; + delete listxattrResponse_reflection_; + delete mkdirRequest::default_instance_; + delete mkdirRequest_reflection_; + delete openRequest::default_instance_; + delete openRequest_reflection_; + delete openResponse::default_instance_; + delete openResponse_reflection_; + delete readdirRequest::default_instance_; + delete readdirRequest_reflection_; + delete readlinkRequest::default_instance_; + delete readlinkRequest_reflection_; + delete readlinkResponse::default_instance_; + delete readlinkResponse_reflection_; + delete removexattrRequest::default_instance_; + delete removexattrRequest_reflection_; + delete renameRequest::default_instance_; + delete renameRequest_reflection_; + delete renameResponse::default_instance_; + delete renameResponse_reflection_; + delete rmdirRequest::default_instance_; + delete rmdirRequest_reflection_; + delete setattrRequest::default_instance_; + delete setattrRequest_reflection_; + delete setxattrRequest::default_instance_; + delete setxattrRequest_reflection_; + delete statvfsRequest::default_instance_; + delete statvfsRequest_reflection_; + delete symlinkRequest::default_instance_; + delete symlinkRequest_reflection_; + delete unlinkRequest::default_instance_; + delete unlinkRequest_reflection_; + delete unlinkResponse::default_instance_; + delete unlinkResponse_reflection_; + delete accessRequest::default_instance_; + delete accessRequest_reflection_; + delete xtreemfs_check_file_existsRequest::default_instance_; + delete xtreemfs_check_file_existsRequest_reflection_; + delete xtreemfs_check_file_existsResponse::default_instance_; + delete xtreemfs_check_file_existsResponse_reflection_; + delete xtreemfs_dump_restore_databaseRequest::default_instance_; + delete xtreemfs_dump_restore_databaseRequest_reflection_; + delete xtreemfs_get_suitable_osdsRequest::default_instance_; + delete xtreemfs_get_suitable_osdsRequest_reflection_; + delete xtreemfs_get_suitable_osdsResponse::default_instance_; + delete xtreemfs_get_suitable_osdsResponse_reflection_; + delete timestampResponse::default_instance_; + delete timestampResponse_reflection_; + delete stringMessage::default_instance_; + delete stringMessage_reflection_; + delete xtreemfs_listdirRequest::default_instance_; + delete xtreemfs_listdirRequest_reflection_; + delete xtreemfs_listdirResponse::default_instance_; + delete xtreemfs_listdirResponse_reflection_; + delete xtreemfs_replica_addRequest::default_instance_; + delete xtreemfs_replica_addRequest_reflection_; + delete xtreemfs_replica_listRequest::default_instance_; + delete xtreemfs_replica_listRequest_reflection_; + delete xtreemfs_get_xlocsetRequest::default_instance_; + delete xtreemfs_get_xlocsetRequest_reflection_; + delete xtreemfs_replica_removeRequest::default_instance_; + delete xtreemfs_replica_removeRequest_reflection_; + delete xtreemfs_restore_fileRequest::default_instance_; + delete xtreemfs_restore_fileRequest_reflection_; + delete xtreemfs_rmvolRequest::default_instance_; + delete xtreemfs_rmvolRequest_reflection_; + delete xtreemfs_update_file_sizeRequest::default_instance_; + delete xtreemfs_update_file_sizeRequest_reflection_; + delete xtreemfs_set_replica_update_policyRequest::default_instance_; + delete xtreemfs_set_replica_update_policyRequest_reflection_; + delete xtreemfs_set_replica_update_policyResponse::default_instance_; + delete xtreemfs_set_replica_update_policyResponse_reflection_; + delete xtreemfs_set_read_only_xattrRequest::default_instance_; + delete xtreemfs_set_read_only_xattrRequest_reflection_; + delete xtreemfs_set_read_only_xattrResponse::default_instance_; + delete xtreemfs_set_read_only_xattrResponse_reflection_; + delete xtreemfs_get_file_credentialsRequest::default_instance_; + delete xtreemfs_get_file_credentialsRequest_reflection_; +} + +void protobuf_AddDesc_xtreemfs_2fMRC_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fPBRPC_2eproto(); + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fCommon_2eproto(); + ::xtreemfs::pbrpc::protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\022xtreemfs/MRC.proto\022\016xtreemfs.pbrpc\032\023in" + "clude/PBRPC.proto\032\024include/Common.proto\032" + "\032xtreemfs/GlobalTypes.proto\"\357\001\n\004Stat\022\013\n\003" + "dev\030\001 \002(\006\022\013\n\003ino\030\002 \002(\006\022\014\n\004mode\030\003 \002(\007\022\r\n\005" + "nlink\030\004 \002(\007\022\017\n\007user_id\030\005 \002(\t\022\020\n\010group_id" + "\030\006 \002(\t\022\014\n\004size\030\007 \002(\006\022\020\n\010atime_ns\030\010 \002(\006\022\020" + "\n\010mtime_ns\030\t \002(\006\022\020\n\010ctime_ns\030\n \002(\006\022\017\n\007bl" + "ksize\030\013 \002(\007\022\014\n\004etag\030\014 \001(\006\022\026\n\016truncate_ep" + "och\030\r \002(\007\022\022\n\nattributes\030\016 \001(\007\"C\n\016Directo" + "ryEntry\022\014\n\004name\030\001 \002(\t\022#\n\005stbuf\030\002 \001(\0132\024.x" + "treemfs.pbrpc.Stat\"C\n\020DirectoryEntries\022/" + "\n\007entries\030\001 \003(\0132\036.xtreemfs.pbrpc.Directo" + "ryEntry\"@\n\005XAttr\022\014\n\004name\030\001 \002(\t\022\r\n\005value\030" + "\002 \001(\t\022\032\n\022value_bytes_string\030\003 \001(\014\"\244\002\n\006Vo" + "lume\022F\n\025access_control_policy\030\001 \002(\0162\'.xt" + "reemfs.pbrpc.AccessControlPolicyType\022\?\n\027" + "default_striping_policy\030\002 \002(\0132\036.xtreemfs" + ".pbrpc.StripingPolicy\022\n\n\002id\030\003 \002(\t\022\014\n\004mod" + "e\030\004 \002(\007\022\014\n\004name\030\005 \002(\t\022\026\n\016owner_group_id\030" + "\006 \002(\t\022\025\n\rowner_user_id\030\007 \002(\t\022+\n\005attrs\030\010 " + "\003(\0132\034.xtreemfs.pbrpc.KeyValuePair\022\r\n\005quo" + "ta\030\t \001(\006\"2\n\007Volumes\022\'\n\007volumes\030\001 \003(\0132\026.x" + "treemfs.pbrpc.Volume\"\310\002\n\007StatVFS\022\r\n\005bsiz" + "e\030\001 \002(\007\022\016\n\006bavail\030\002 \002(\006\022\r\n\005bfree\030\r \001(\006\022\016" + "\n\006blocks\030\003 \002(\006\022\014\n\004fsid\030\004 \002(\t\022\017\n\007namemax\030" + "\005 \002(\007\022F\n\025access_control_policy\030\006 \002(\0162\'.x" + "treemfs.pbrpc.AccessControlPolicyType\022\?\n" + "\027default_striping_policy\030\007 \002(\0132\036.xtreemf" + "s.pbrpc.StripingPolicy\022\014\n\004etag\030\010 \002(\006\022\014\n\004" + "mode\030\t \002(\007\022\014\n\004name\030\n \002(\t\022\026\n\016owner_group_" + "id\030\013 \002(\t\022\025\n\rowner_user_id\030\014 \002(\t\"i\n\017fseta" + "ttrRequest\022#\n\005stbuf\030\001 \002(\0132\024.xtreemfs.pbr" + "pc.Stat\022\016\n\006to_set\030\002 \002(\007\022!\n\003cap\030\003 \002(\0132\024.x" + "treemfs.pbrpc.XCap\"G\n\016getattrRequest\022\023\n\013" + "volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\022\022\n\nknown" + "_etag\030\003 \002(\006\"6\n\017getattrResponse\022#\n\005stbuf\030" + "\001 \001(\0132\024.xtreemfs.pbrpc.Stat\"B\n\017getxattrR" + "equest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(" + "\t\022\014\n\004name\030\003 \002(\t\"=\n\020getxattrResponse\022\r\n\005v" + "alue\030\001 \002(\t\022\032\n\022value_bytes_string\030\002 \001(\014\"J" + "\n\013linkRequest\022\023\n\013volume_name\030\001 \002(\t\022\023\n\013ta" + "rget_path\030\002 \002(\t\022\021\n\tlink_path\030\003 \002(\t\"I\n\020li" + "stxattrRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004p" + "ath\030\002 \002(\t\022\022\n\nnames_only\030\003 \002(\010\":\n\021listxat" + "trResponse\022%\n\006xattrs\030\001 \003(\0132\025.xtreemfs.pb" + "rpc.XAttr\"\?\n\014mkdirRequest\022\023\n\013volume_name" + "\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\022\014\n\004mode\030\003 \002(\007\"\232\001\n\013o" + "penRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030" + "\002 \002(\t\022\r\n\005flags\030\003 \002(\007\022\014\n\004mode\030\004 \002(\007\022\022\n\nat" + "tributes\030\005 \002(\007\0227\n\013coordinates\030\006 \001(\0132\".xt" + "reemfs.pbrpc.VivaldiCoordinates\"S\n\014openR" + "esponse\022.\n\005creds\030\001 \002(\0132\037.xtreemfs.pbrpc." + "FileCredentials\022\023\n\013timestamp_s\030\002 \002(\007\"\250\001\n" + "\016readdirRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004" + "path\030\002 \002(\t\022\022\n\nknown_etag\030\003 \002(\006\022%\n\035limit_" + "directory_entries_count\030\004 \002(\007\022\022\n\nnames_o" + "nly\030\005 \002(\010\022$\n\034seen_directory_entries_coun" + "t\030\006 \002(\006\"4\n\017readlinkRequest\022\023\n\013volume_nam" + "e\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\",\n\020readlinkRespons" + "e\022\030\n\020link_target_path\030\001 \003(\t\"E\n\022removexat" + "trRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002" + " \002(\t\022\014\n\004name\030\003 \002(\t\"N\n\rrenameRequest\022\023\n\013v" + "olume_name\030\001 \002(\t\022\023\n\013source_path\030\002 \002(\t\022\023\n" + "\013target_path\030\003 \002(\t\"U\n\016renameResponse\022\023\n\013" + "timestamp_s\030\001 \002(\007\022.\n\005creds\030\002 \001(\0132\037.xtree" + "mfs.pbrpc.FileCredentials\"1\n\014rmdirReques" + "t\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\"h\n\016" + "setattrRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004p" + "ath\030\002 \002(\t\022#\n\005stbuf\030\003 \002(\0132\024.xtreemfs.pbrp" + "c.Stat\022\016\n\006to_set\030\004 \002(\007\"|\n\017setxattrReques" + "t\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\022\014\n\004" + "name\030\003 \002(\t\022\r\n\005value\030\004 \002(\t\022\032\n\022value_bytes" + "_string\030\006 \001(\014\022\r\n\005flags\030\005 \002(\007\"9\n\016statvfsR" + "equest\022\023\n\013volume_name\030\001 \002(\t\022\022\n\nknown_eta" + "g\030\005 \002(\006\"M\n\016symlinkRequest\022\023\n\013volume_name" + "\030\001 \002(\t\022\023\n\013target_path\030\002 \002(\t\022\021\n\tlink_path" + "\030\003 \002(\t\"2\n\runlinkRequest\022\023\n\013volume_name\030\001" + " \002(\t\022\014\n\004path\030\002 \002(\t\"U\n\016unlinkResponse\022\023\n\013" + "timestamp_s\030\001 \002(\007\022.\n\005creds\030\002 \001(\0132\037.xtree" + "mfs.pbrpc.FileCredentials\"A\n\raccessReque" + "st\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\022\r\n" + "\005flags\030\003 \002(\007\"Z\n!xtreemfs_check_file_exis" + "tsRequest\022\021\n\tvolume_id\030\001 \002(\t\022\020\n\010file_ids" + "\030\002 \003(\t\022\020\n\010osd_uuid\030\003 \002(\t\"\315\001\n\"xtreemfs_ch" + "eck_file_existsResponse\022\025\n\rvolume_exists" + "\030\001 \002(\010\022V\n\013file_states\030\002 \003(\0162=.xtreemfs.p" + "brpc.xtreemfs_check_file_existsResponse." + "FILE_STATEB\002\020\001\"8\n\nFILE_STATE\022\013\n\007DELETED\020" + "\000\022\016\n\nREGISTERED\020\001\022\r\n\tABANDONED\020\002\":\n%xtre" + "emfs_dump_restore_databaseRequest\022\021\n\tdum" + "p_file\030\001 \002(\t\"i\n!xtreemfs_get_suitable_os" + "dsRequest\022\017\n\007file_id\030\001 \001(\t\022\014\n\004path\030\003 \001(\t" + "\022\023\n\013volume_name\030\004 \001(\t\022\020\n\010num_osds\030\002 \002(\007\"" + "7\n\"xtreemfs_get_suitable_osdsResponse\022\021\n" + "\tosd_uuids\030\001 \003(\t\"(\n\021timestampResponse\022\023\n" + "\013timestamp_s\030\001 \002(\007\"!\n\rstringMessage\022\020\n\010a" + "_string\030\001 \002(\t\"\'\n\027xtreemfs_listdirRequest" + "\022\014\n\004path\030\001 \002(\t\")\n\030xtreemfs_listdirRespon" + "se\022\r\n\005names\030\001 \003(\t\"\177\n\033xtreemfs_replica_ad" + "dRequest\022\017\n\007file_id\030\001 \001(\t\022\014\n\004path\030\003 \001(\t\022" + "\023\n\013volume_name\030\004 \001(\t\022,\n\013new_replica\030\002 \002(" + "\0132\027.xtreemfs.pbrpc.Replica\"R\n\034xtreemfs_r" + "eplica_listRequest\022\017\n\007file_id\030\001 \001(\t\022\014\n\004p" + "ath\030\002 \001(\t\022\023\n\013volume_name\030\003 \001(\t\"u\n\033xtreem" + "fs_get_xlocsetRequest\022\017\n\007file_id\030\001 \001(\t\022\014" + "\n\004path\030\002 \001(\t\022\023\n\013volume_name\030\003 \001(\t\022\"\n\004xca" + "p\030\004 \001(\0132\024.xtreemfs.pbrpc.XCap\"f\n\036xtreemf" + "s_replica_removeRequest\022\017\n\007file_id\030\001 \001(\t" + "\022\014\n\004path\030\003 \001(\t\022\023\n\013volume_name\030\004 \001(\t\022\020\n\010o" + "sd_uuid\030\002 \002(\t\"|\n\034xtreemfs_restore_fileRe" + "quest\022\021\n\tfile_path\030\001 \002(\t\022\017\n\007file_id\030\002 \002(" + "\t\022\021\n\tfile_size\030\003 \002(\006\022\020\n\010osd_uuid\030\004 \002(\t\022\023" + "\n\013stripe_size\030\005 \002(\007\",\n\025xtreemfs_rmvolReq" + "uest\022\023\n\013volume_name\030\001 \002(\t\"\321\001\n xtreemfs_u" + "pdate_file_sizeRequest\022\"\n\004xcap\030\001 \002(\0132\024.x" + "treemfs.pbrpc.XCap\022<\n\022osd_write_response" + "\030\002 \002(\0132 .xtreemfs.pbrpc.OSDWriteResponse" + "\022\022\n\nclose_file\030\003 \001(\010\0227\n\013coordinates\030\004 \001(" + "\0132\".xtreemfs.pbrpc.VivaldiCoordinates\"S\n" + ")xtreemfs_set_replica_update_policyReque" + "st\022\017\n\007file_id\030\001 \002(\t\022\025\n\rupdate_policy\030\002 \002" + "(\t\"G\n*xtreemfs_set_replica_update_policy" + "Response\022\031\n\021old_update_policy\030\001 \002(\t\"E\n#x" + "treemfs_set_read_only_xattrRequest\022\017\n\007fi" + "le_id\030\001 \002(\t\022\r\n\005value\030\002 \002(\010\"7\n$xtreemfs_s" + "et_read_only_xattrResponse\022\017\n\007was_set\030\001 " + "\002(\010\"7\n$xtreemfs_get_file_credentialsRequ" + "est\022\017\n\007file_id\030\001 \002(\t*\242\001\n\010Setattrs\022\020\n\014SET" + "ATTR_MODE\020\001\022\017\n\013SETATTR_UID\020\002\022\017\n\013SETATTR_" + "GID\020\004\022\020\n\014SETATTR_SIZE\020\010\022\021\n\rSETATTR_ATIME" + "\020\020\022\021\n\rSETATTR_MTIME\020 \022\021\n\rSETATTR_CTIME\020@" + "\022\027\n\022SETATTR_ATTRIBUTES\020\200\001*>\n\013XATTR_FLAGS" + "\022\026\n\022XATTR_FLAGS_CREATE\020\001\022\027\n\023XATTR_FLAGS_" + "REPLACE\020\002*j\n\014ACCESS_FLAGS\022\025\n\021ACCESS_FLAG" + "S_F_OK\020\000\022\025\n\021ACCESS_FLAGS_X_OK\020\001\022\025\n\021ACCES" + "S_FLAGS_W_OK\020\002\022\025\n\021ACCESS_FLAGS_R_OK\020\0042\203 " + "\n\nMRCService\022S\n\010fsetattr\022\037.xtreemfs.pbrp" + "c.fsetattrRequest\032\035.xtreemfs.pbrpc.empty" + "Response\"\007\215\265\030\002\000\000\000\022@\n\tftruncate\022\024.xtreemf" + "s.pbrpc.XCap\032\024.xtreemfs.pbrpc.XCap\"\007\215\265\030\003" + "\000\000\000\022S\n\007getattr\022\036.xtreemfs.pbrpc.getattrR" + "equest\032\037.xtreemfs.pbrpc.getattrResponse\"" + "\007\215\265\030\004\000\000\000\022V\n\010getxattr\022\037.xtreemfs.pbrpc.ge" + "txattrRequest\032 .xtreemfs.pbrpc.getxattrR" + "esponse\"\007\215\265\030\005\000\000\000\022O\n\004link\022\033.xtreemfs.pbrp" + "c.linkRequest\032!.xtreemfs.pbrpc.timestamp" + "Response\"\007\215\265\030\006\000\000\000\022Y\n\tlistxattr\022 .xtreemf" + "s.pbrpc.listxattrRequest\032!.xtreemfs.pbrp" + "c.listxattrResponse\"\007\215\265\030\007\000\000\000\022Q\n\005mkdir\022\034." + "xtreemfs.pbrpc.mkdirRequest\032!.xtreemfs.p" + "brpc.timestampResponse\"\007\215\265\030\010\000\000\000\022J\n\004open\022" + "\033.xtreemfs.pbrpc.openRequest\032\034.xtreemfs." + "pbrpc.openResponse\"\007\215\265\030\t\000\000\000\022T\n\007readdir\022\036" + ".xtreemfs.pbrpc.readdirRequest\032 .xtreemf" + "s.pbrpc.DirectoryEntries\"\007\215\265\030\n\000\000\000\022V\n\010rea" + "dlink\022\037.xtreemfs.pbrpc.readlinkRequest\032 " + ".xtreemfs.pbrpc.readlinkResponse\"\007\215\265\030\013\000\000" + "\000\022]\n\013removexattr\022\".xtreemfs.pbrpc.remove" + "xattrRequest\032!.xtreemfs.pbrpc.timestampR" + "esponse\"\007\215\265\030\014\000\000\000\022P\n\006rename\022\035.xtreemfs.pb" + "rpc.renameRequest\032\036.xtreemfs.pbrpc.renam" + "eResponse\"\007\215\265\030\r\000\000\000\022Q\n\005rmdir\022\034.xtreemfs.p" + "brpc.rmdirRequest\032!.xtreemfs.pbrpc.times" + "tampResponse\"\007\215\265\030\016\000\000\000\022U\n\007setattr\022\036.xtree" + "mfs.pbrpc.setattrRequest\032!.xtreemfs.pbrp" + "c.timestampResponse\"\007\215\265\030\017\000\000\000\022W\n\010setxattr" + "\022\037.xtreemfs.pbrpc.setxattrRequest\032!.xtre" + "emfs.pbrpc.timestampResponse\"\007\215\265\030\020\000\000\000\022K\n" + "\007statvfs\022\036.xtreemfs.pbrpc.statvfsRequest" + "\032\027.xtreemfs.pbrpc.StatVFS\"\007\215\265\030\021\000\000\000\022U\n\007sy" + "mlink\022\036.xtreemfs.pbrpc.symlinkRequest\032!." + "xtreemfs.pbrpc.timestampResponse\"\007\215\265\030\022\000\000" + "\000\022P\n\006unlink\022\035.xtreemfs.pbrpc.unlinkReque" + "st\032\036.xtreemfs.pbrpc.unlinkResponse\"\007\215\265\030\023" + "\000\000\000\022O\n\006access\022\035.xtreemfs.pbrpc.accessReq" + "uest\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265\030" + "\024\000\000\000\022[\n\023xtreemfs_checkpoint\022\034.xtreemfs.p" + "brpc.emptyRequest\032\035.xtreemfs.pbrpc.empty" + "Response\"\007\215\265\030\036\000\000\000\022\214\001\n\032xtreemfs_check_fil" + "e_exists\0221.xtreemfs.pbrpc.xtreemfs_check" + "_file_existsRequest\0322.xtreemfs.pbrpc.xtr" + "eemfs_check_file_existsResponse\"\007\215\265\030\037\000\000\000" + "\022w\n\026xtreemfs_dump_database\0225.xtreemfs.pb" + "rpc.xtreemfs_dump_restore_databaseReques" + "t\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265\030 \000\000" + "\000\022\214\001\n\032xtreemfs_get_suitable_osds\0221.xtree" + "mfs.pbrpc.xtreemfs_get_suitable_osdsRequ" + "est\0322.xtreemfs.pbrpc.xtreemfs_get_suitab" + "le_osdsResponse\"\007\215\265\030!\000\000\000\022`\n\027xtreemfs_int" + "ernal_debug\022\035.xtreemfs.pbrpc.stringMessa" + "ge\032\035.xtreemfs.pbrpc.stringMessage\"\007\215\265\030\"\000" + "\000\000\022n\n\020xtreemfs_listdir\022\'.xtreemfs.pbrpc." + "xtreemfs_listdirRequest\032(.xtreemfs.pbrpc" + ".xtreemfs_listdirResponse\"\007\215\265\030#\000\000\000\022P\n\016xt" + "reemfs_lsvol\022\034.xtreemfs.pbrpc.emptyReque" + "st\032\027.xtreemfs.pbrpc.Volumes\"\007\215\265\030$\000\000\000\022P\n\016" + "xtreemfs_mkvol\022\026.xtreemfs.pbrpc.Volume\032\035" + ".xtreemfs.pbrpc.emptyResponse\"\007\215\265\030/\000\000\000\022P" + "\n\031xtreemfs_renew_capability\022\024.xtreemfs.p" + "brpc.XCap\032\024.xtreemfs.pbrpc.XCap\"\007\215\265\030%\000\000\000" + "\022f\n\036xtreemfs_replication_to_master\022\034.xtr" + "eemfs.pbrpc.emptyRequest\032\035.xtreemfs.pbrp" + "c.emptyResponse\"\007\215\265\030&\000\000\000\022k\n\024xtreemfs_rep" + "lica_add\022+.xtreemfs.pbrpc.xtreemfs_repli" + "ca_addRequest\032\035.xtreemfs.pbrpc.emptyResp" + "onse\"\007\215\265\030\'\000\000\000\022h\n\025xtreemfs_replica_list\022," + ".xtreemfs.pbrpc.xtreemfs_replica_listReq" + "uest\032\030.xtreemfs.pbrpc.Replicas\"\007\215\265\030(\000\000\000\022" + "s\n\027xtreemfs_replica_remove\022..xtreemfs.pb" + "rpc.xtreemfs_replica_removeRequest\032\037.xtr" + "eemfs.pbrpc.FileCredentials\"\007\215\265\030)\000\000\000\022z\n\031" + "xtreemfs_restore_database\0225.xtreemfs.pbr" + "pc.xtreemfs_dump_restore_databaseRequest" + "\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265\030*\000\000\000" + "\022m\n\025xtreemfs_restore_file\022,.xtreemfs.pbr" + "pc.xtreemfs_restore_fileRequest\032\035.xtreem" + "fs.pbrpc.emptyResponse\"\007\215\265\030+\000\000\000\022_\n\016xtree" + "mfs_rmvol\022%.xtreemfs.pbrpc.xtreemfs_rmvo" + "lRequest\032\035.xtreemfs.pbrpc.emptyResponse\"" + "\007\215\265\030,\000\000\000\022Y\n\021xtreemfs_shutdown\022\034.xtreemfs" + ".pbrpc.emptyRequest\032\035.xtreemfs.pbrpc.emp" + "tyResponse\"\007\215\265\030-\000\000\000\022y\n\031xtreemfs_update_f" + "ile_size\0220.xtreemfs.pbrpc.xtreemfs_updat" + "e_file_sizeRequest\032!.xtreemfs.pbrpc.time" + "stampResponse\"\007\215\265\030.\000\000\000\022\244\001\n\"xtreemfs_set_" + "replica_update_policy\0229.xtreemfs.pbrpc.x" + "treemfs_set_replica_update_policyRequest" + "\032:.xtreemfs.pbrpc.xtreemfs_set_replica_u" + "pdate_policyResponse\"\007\215\265\0300\000\000\000\022\222\001\n\034xtreem" + "fs_set_read_only_xattr\0223.xtreemfs.pbrpc." + "xtreemfs_set_read_only_xattrRequest\0324.xt" + "reemfs.pbrpc.xtreemfs_set_read_only_xatt" + "rResponse\"\007\215\265\0301\000\000\000\022\177\n\035xtreemfs_get_file_" + "credentials\0224.xtreemfs.pbrpc.xtreemfs_ge" + "t_file_credentialsRequest\032\037.xtreemfs.pbr" + "pc.FileCredentials\"\007\215\265\0302\000\000\000\022e\n\024xtreemfs_" + "get_xlocset\022+.xtreemfs.pbrpc.xtreemfs_ge" + "t_xlocsetRequest\032\027.xtreemfs.pbrpc.XLocSe" + "t\"\007\215\265\0303\000\000\000\032\007\225\265\030!N\000\000B(\n&org.xtreemfs.pbrp" + "c.generatedinterfaces", 9581); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "xtreemfs/MRC.proto", &protobuf_RegisterTypes); + Stat::default_instance_ = new Stat(); + DirectoryEntry::default_instance_ = new DirectoryEntry(); + DirectoryEntries::default_instance_ = new DirectoryEntries(); + XAttr::default_instance_ = new XAttr(); + Volume::default_instance_ = new Volume(); + Volumes::default_instance_ = new Volumes(); + StatVFS::default_instance_ = new StatVFS(); + fsetattrRequest::default_instance_ = new fsetattrRequest(); + getattrRequest::default_instance_ = new getattrRequest(); + getattrResponse::default_instance_ = new getattrResponse(); + getxattrRequest::default_instance_ = new getxattrRequest(); + getxattrResponse::default_instance_ = new getxattrResponse(); + linkRequest::default_instance_ = new linkRequest(); + listxattrRequest::default_instance_ = new listxattrRequest(); + listxattrResponse::default_instance_ = new listxattrResponse(); + mkdirRequest::default_instance_ = new mkdirRequest(); + openRequest::default_instance_ = new openRequest(); + openResponse::default_instance_ = new openResponse(); + readdirRequest::default_instance_ = new readdirRequest(); + readlinkRequest::default_instance_ = new readlinkRequest(); + readlinkResponse::default_instance_ = new readlinkResponse(); + removexattrRequest::default_instance_ = new removexattrRequest(); + renameRequest::default_instance_ = new renameRequest(); + renameResponse::default_instance_ = new renameResponse(); + rmdirRequest::default_instance_ = new rmdirRequest(); + setattrRequest::default_instance_ = new setattrRequest(); + setxattrRequest::default_instance_ = new setxattrRequest(); + statvfsRequest::default_instance_ = new statvfsRequest(); + symlinkRequest::default_instance_ = new symlinkRequest(); + unlinkRequest::default_instance_ = new unlinkRequest(); + unlinkResponse::default_instance_ = new unlinkResponse(); + accessRequest::default_instance_ = new accessRequest(); + xtreemfs_check_file_existsRequest::default_instance_ = new xtreemfs_check_file_existsRequest(); + xtreemfs_check_file_existsResponse::default_instance_ = new xtreemfs_check_file_existsResponse(); + xtreemfs_dump_restore_databaseRequest::default_instance_ = new xtreemfs_dump_restore_databaseRequest(); + xtreemfs_get_suitable_osdsRequest::default_instance_ = new xtreemfs_get_suitable_osdsRequest(); + xtreemfs_get_suitable_osdsResponse::default_instance_ = new xtreemfs_get_suitable_osdsResponse(); + timestampResponse::default_instance_ = new timestampResponse(); + stringMessage::default_instance_ = new stringMessage(); + xtreemfs_listdirRequest::default_instance_ = new xtreemfs_listdirRequest(); + xtreemfs_listdirResponse::default_instance_ = new xtreemfs_listdirResponse(); + xtreemfs_replica_addRequest::default_instance_ = new xtreemfs_replica_addRequest(); + xtreemfs_replica_listRequest::default_instance_ = new xtreemfs_replica_listRequest(); + xtreemfs_get_xlocsetRequest::default_instance_ = new xtreemfs_get_xlocsetRequest(); + xtreemfs_replica_removeRequest::default_instance_ = new xtreemfs_replica_removeRequest(); + xtreemfs_restore_fileRequest::default_instance_ = new xtreemfs_restore_fileRequest(); + xtreemfs_rmvolRequest::default_instance_ = new xtreemfs_rmvolRequest(); + xtreemfs_update_file_sizeRequest::default_instance_ = new xtreemfs_update_file_sizeRequest(); + xtreemfs_set_replica_update_policyRequest::default_instance_ = new xtreemfs_set_replica_update_policyRequest(); + xtreemfs_set_replica_update_policyResponse::default_instance_ = new xtreemfs_set_replica_update_policyResponse(); + xtreemfs_set_read_only_xattrRequest::default_instance_ = new xtreemfs_set_read_only_xattrRequest(); + xtreemfs_set_read_only_xattrResponse::default_instance_ = new xtreemfs_set_read_only_xattrResponse(); + xtreemfs_get_file_credentialsRequest::default_instance_ = new xtreemfs_get_file_credentialsRequest(); + Stat::default_instance_->InitAsDefaultInstance(); + DirectoryEntry::default_instance_->InitAsDefaultInstance(); + DirectoryEntries::default_instance_->InitAsDefaultInstance(); + XAttr::default_instance_->InitAsDefaultInstance(); + Volume::default_instance_->InitAsDefaultInstance(); + Volumes::default_instance_->InitAsDefaultInstance(); + StatVFS::default_instance_->InitAsDefaultInstance(); + fsetattrRequest::default_instance_->InitAsDefaultInstance(); + getattrRequest::default_instance_->InitAsDefaultInstance(); + getattrResponse::default_instance_->InitAsDefaultInstance(); + getxattrRequest::default_instance_->InitAsDefaultInstance(); + getxattrResponse::default_instance_->InitAsDefaultInstance(); + linkRequest::default_instance_->InitAsDefaultInstance(); + listxattrRequest::default_instance_->InitAsDefaultInstance(); + listxattrResponse::default_instance_->InitAsDefaultInstance(); + mkdirRequest::default_instance_->InitAsDefaultInstance(); + openRequest::default_instance_->InitAsDefaultInstance(); + openResponse::default_instance_->InitAsDefaultInstance(); + readdirRequest::default_instance_->InitAsDefaultInstance(); + readlinkRequest::default_instance_->InitAsDefaultInstance(); + readlinkResponse::default_instance_->InitAsDefaultInstance(); + removexattrRequest::default_instance_->InitAsDefaultInstance(); + renameRequest::default_instance_->InitAsDefaultInstance(); + renameResponse::default_instance_->InitAsDefaultInstance(); + rmdirRequest::default_instance_->InitAsDefaultInstance(); + setattrRequest::default_instance_->InitAsDefaultInstance(); + setxattrRequest::default_instance_->InitAsDefaultInstance(); + statvfsRequest::default_instance_->InitAsDefaultInstance(); + symlinkRequest::default_instance_->InitAsDefaultInstance(); + unlinkRequest::default_instance_->InitAsDefaultInstance(); + unlinkResponse::default_instance_->InitAsDefaultInstance(); + accessRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_check_file_existsRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_check_file_existsResponse::default_instance_->InitAsDefaultInstance(); + xtreemfs_dump_restore_databaseRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_get_suitable_osdsRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_get_suitable_osdsResponse::default_instance_->InitAsDefaultInstance(); + timestampResponse::default_instance_->InitAsDefaultInstance(); + stringMessage::default_instance_->InitAsDefaultInstance(); + xtreemfs_listdirRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_listdirResponse::default_instance_->InitAsDefaultInstance(); + xtreemfs_replica_addRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_replica_listRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_get_xlocsetRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_replica_removeRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_restore_fileRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_rmvolRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_update_file_sizeRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_set_replica_update_policyRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_set_replica_update_policyResponse::default_instance_->InitAsDefaultInstance(); + xtreemfs_set_read_only_xattrRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_set_read_only_xattrResponse::default_instance_->InitAsDefaultInstance(); + xtreemfs_get_file_credentialsRequest::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_xtreemfs_2fMRC_2eproto { + StaticDescriptorInitializer_xtreemfs_2fMRC_2eproto() { + protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + } +} static_descriptor_initializer_xtreemfs_2fMRC_2eproto_; +const ::google::protobuf::EnumDescriptor* Setattrs_descriptor() { + protobuf_AssignDescriptorsOnce(); + return Setattrs_descriptor_; +} +bool Setattrs_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 4: + case 8: + case 16: + case 32: + case 64: + case 128: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* XATTR_FLAGS_descriptor() { + protobuf_AssignDescriptorsOnce(); + return XATTR_FLAGS_descriptor_; +} +bool XATTR_FLAGS_IsValid(int value) { + switch(value) { + case 1: + case 2: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* ACCESS_FLAGS_descriptor() { + protobuf_AssignDescriptorsOnce(); + return ACCESS_FLAGS_descriptor_; +} +bool ACCESS_FLAGS_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 4: + return true; + default: + return false; + } +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Stat::kDevFieldNumber; +const int Stat::kInoFieldNumber; +const int Stat::kModeFieldNumber; +const int Stat::kNlinkFieldNumber; +const int Stat::kUserIdFieldNumber; +const int Stat::kGroupIdFieldNumber; +const int Stat::kSizeFieldNumber; +const int Stat::kAtimeNsFieldNumber; +const int Stat::kMtimeNsFieldNumber; +const int Stat::kCtimeNsFieldNumber; +const int Stat::kBlksizeFieldNumber; +const int Stat::kEtagFieldNumber; +const int Stat::kTruncateEpochFieldNumber; +const int Stat::kAttributesFieldNumber; +#endif // !_MSC_VER + +Stat::Stat() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Stat::InitAsDefaultInstance() { +} + +Stat::Stat(const Stat& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Stat::SharedCtor() { + _cached_size_ = 0; + dev_ = GOOGLE_ULONGLONG(0); + ino_ = GOOGLE_ULONGLONG(0); + mode_ = 0u; + nlink_ = 0u; + user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + size_ = GOOGLE_ULONGLONG(0); + atime_ns_ = GOOGLE_ULONGLONG(0); + mtime_ns_ = GOOGLE_ULONGLONG(0); + ctime_ns_ = GOOGLE_ULONGLONG(0); + blksize_ = 0u; + etag_ = GOOGLE_ULONGLONG(0); + truncate_epoch_ = 0u; + attributes_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Stat::~Stat() { + SharedDtor(); +} + +void Stat::SharedDtor() { + if (user_id_ != &::google::protobuf::internal::kEmptyString) { + delete user_id_; + } + if (group_id_ != &::google::protobuf::internal::kEmptyString) { + delete group_id_; + } + if (this != default_instance_) { + } +} + +void Stat::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Stat::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Stat_descriptor_; +} + +const Stat& Stat::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +Stat* Stat::default_instance_ = NULL; + +Stat* Stat::New() const { + return new Stat; +} + +void Stat::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + dev_ = GOOGLE_ULONGLONG(0); + ino_ = GOOGLE_ULONGLONG(0); + mode_ = 0u; + nlink_ = 0u; + if (has_user_id()) { + if (user_id_ != &::google::protobuf::internal::kEmptyString) { + user_id_->clear(); + } + } + if (has_group_id()) { + if (group_id_ != &::google::protobuf::internal::kEmptyString) { + group_id_->clear(); + } + } + size_ = GOOGLE_ULONGLONG(0); + atime_ns_ = GOOGLE_ULONGLONG(0); + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + mtime_ns_ = GOOGLE_ULONGLONG(0); + ctime_ns_ = GOOGLE_ULONGLONG(0); + blksize_ = 0u; + etag_ = GOOGLE_ULONGLONG(0); + truncate_epoch_ = 0u; + attributes_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Stat::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 dev = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &dev_))); + set_has_dev(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_ino; + break; + } + + // required fixed64 ino = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_ino: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &ino_))); + set_has_ino(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_mode; + break; + } + + // required fixed32 mode = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_mode: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &mode_))); + set_has_mode(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_nlink; + break; + } + + // required fixed32 nlink = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_nlink: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &nlink_))); + set_has_nlink(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_user_id; + break; + } + + // required string user_id = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_user_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_user_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->user_id().data(), this->user_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_group_id; + break; + } + + // required string group_id = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_group_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_group_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->group_id().data(), this->group_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(57)) goto parse_size; + break; + } + + // required fixed64 size = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &size_))); + set_has_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(65)) goto parse_atime_ns; + break; + } + + // required fixed64 atime_ns = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_atime_ns: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &atime_ns_))); + set_has_atime_ns(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(73)) goto parse_mtime_ns; + break; + } + + // required fixed64 mtime_ns = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_mtime_ns: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &mtime_ns_))); + set_has_mtime_ns(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(81)) goto parse_ctime_ns; + break; + } + + // required fixed64 ctime_ns = 10; + case 10: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_ctime_ns: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &ctime_ns_))); + set_has_ctime_ns(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(93)) goto parse_blksize; + break; + } + + // required fixed32 blksize = 11; + case 11: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_blksize: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &blksize_))); + set_has_blksize(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(97)) goto parse_etag; + break; + } + + // optional fixed64 etag = 12; + case 12: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_etag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &etag_))); + set_has_etag(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(109)) goto parse_truncate_epoch; + break; + } + + // required fixed32 truncate_epoch = 13; + case 13: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_truncate_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &truncate_epoch_))); + set_has_truncate_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(117)) goto parse_attributes; + break; + } + + // optional fixed32 attributes = 14; + case 14: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_attributes: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &attributes_))); + set_has_attributes(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Stat::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 dev = 1; + if (has_dev()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->dev(), output); + } + + // required fixed64 ino = 2; + if (has_ino()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->ino(), output); + } + + // required fixed32 mode = 3; + if (has_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->mode(), output); + } + + // required fixed32 nlink = 4; + if (has_nlink()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->nlink(), output); + } + + // required string user_id = 5; + if (has_user_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->user_id().data(), this->user_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 5, this->user_id(), output); + } + + // required string group_id = 6; + if (has_group_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->group_id().data(), this->group_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 6, this->group_id(), output); + } + + // required fixed64 size = 7; + if (has_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(7, this->size(), output); + } + + // required fixed64 atime_ns = 8; + if (has_atime_ns()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(8, this->atime_ns(), output); + } + + // required fixed64 mtime_ns = 9; + if (has_mtime_ns()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(9, this->mtime_ns(), output); + } + + // required fixed64 ctime_ns = 10; + if (has_ctime_ns()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(10, this->ctime_ns(), output); + } + + // required fixed32 blksize = 11; + if (has_blksize()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->blksize(), output); + } + + // optional fixed64 etag = 12; + if (has_etag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(12, this->etag(), output); + } + + // required fixed32 truncate_epoch = 13; + if (has_truncate_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(13, this->truncate_epoch(), output); + } + + // optional fixed32 attributes = 14; + if (has_attributes()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(14, this->attributes(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Stat::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 dev = 1; + if (has_dev()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->dev(), target); + } + + // required fixed64 ino = 2; + if (has_ino()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->ino(), target); + } + + // required fixed32 mode = 3; + if (has_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->mode(), target); + } + + // required fixed32 nlink = 4; + if (has_nlink()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->nlink(), target); + } + + // required string user_id = 5; + if (has_user_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->user_id().data(), this->user_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->user_id(), target); + } + + // required string group_id = 6; + if (has_group_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->group_id().data(), this->group_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->group_id(), target); + } + + // required fixed64 size = 7; + if (has_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(7, this->size(), target); + } + + // required fixed64 atime_ns = 8; + if (has_atime_ns()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(8, this->atime_ns(), target); + } + + // required fixed64 mtime_ns = 9; + if (has_mtime_ns()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(9, this->mtime_ns(), target); + } + + // required fixed64 ctime_ns = 10; + if (has_ctime_ns()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(10, this->ctime_ns(), target); + } + + // required fixed32 blksize = 11; + if (has_blksize()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->blksize(), target); + } + + // optional fixed64 etag = 12; + if (has_etag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(12, this->etag(), target); + } + + // required fixed32 truncate_epoch = 13; + if (has_truncate_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(13, this->truncate_epoch(), target); + } + + // optional fixed32 attributes = 14; + if (has_attributes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(14, this->attributes(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Stat::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 dev = 1; + if (has_dev()) { + total_size += 1 + 8; + } + + // required fixed64 ino = 2; + if (has_ino()) { + total_size += 1 + 8; + } + + // required fixed32 mode = 3; + if (has_mode()) { + total_size += 1 + 4; + } + + // required fixed32 nlink = 4; + if (has_nlink()) { + total_size += 1 + 4; + } + + // required string user_id = 5; + if (has_user_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->user_id()); + } + + // required string group_id = 6; + if (has_group_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->group_id()); + } + + // required fixed64 size = 7; + if (has_size()) { + total_size += 1 + 8; + } + + // required fixed64 atime_ns = 8; + if (has_atime_ns()) { + total_size += 1 + 8; + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // required fixed64 mtime_ns = 9; + if (has_mtime_ns()) { + total_size += 1 + 8; + } + + // required fixed64 ctime_ns = 10; + if (has_ctime_ns()) { + total_size += 1 + 8; + } + + // required fixed32 blksize = 11; + if (has_blksize()) { + total_size += 1 + 4; + } + + // optional fixed64 etag = 12; + if (has_etag()) { + total_size += 1 + 8; + } + + // required fixed32 truncate_epoch = 13; + if (has_truncate_epoch()) { + total_size += 1 + 4; + } + + // optional fixed32 attributes = 14; + if (has_attributes()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Stat::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Stat* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Stat::MergeFrom(const Stat& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_dev()) { + set_dev(from.dev()); + } + if (from.has_ino()) { + set_ino(from.ino()); + } + if (from.has_mode()) { + set_mode(from.mode()); + } + if (from.has_nlink()) { + set_nlink(from.nlink()); + } + if (from.has_user_id()) { + set_user_id(from.user_id()); + } + if (from.has_group_id()) { + set_group_id(from.group_id()); + } + if (from.has_size()) { + set_size(from.size()); + } + if (from.has_atime_ns()) { + set_atime_ns(from.atime_ns()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_mtime_ns()) { + set_mtime_ns(from.mtime_ns()); + } + if (from.has_ctime_ns()) { + set_ctime_ns(from.ctime_ns()); + } + if (from.has_blksize()) { + set_blksize(from.blksize()); + } + if (from.has_etag()) { + set_etag(from.etag()); + } + if (from.has_truncate_epoch()) { + set_truncate_epoch(from.truncate_epoch()); + } + if (from.has_attributes()) { + set_attributes(from.attributes()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Stat::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Stat::CopyFrom(const Stat& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Stat::IsInitialized() const { + if ((_has_bits_[0] & 0x000017ff) != 0x000017ff) return false; + + return true; +} + +void Stat::Swap(Stat* other) { + if (other != this) { + std::swap(dev_, other->dev_); + std::swap(ino_, other->ino_); + std::swap(mode_, other->mode_); + std::swap(nlink_, other->nlink_); + std::swap(user_id_, other->user_id_); + std::swap(group_id_, other->group_id_); + std::swap(size_, other->size_); + std::swap(atime_ns_, other->atime_ns_); + std::swap(mtime_ns_, other->mtime_ns_); + std::swap(ctime_ns_, other->ctime_ns_); + std::swap(blksize_, other->blksize_); + std::swap(etag_, other->etag_); + std::swap(truncate_epoch_, other->truncate_epoch_); + std::swap(attributes_, other->attributes_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Stat::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Stat_descriptor_; + metadata.reflection = Stat_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DirectoryEntry::kNameFieldNumber; +const int DirectoryEntry::kStbufFieldNumber; +#endif // !_MSC_VER + +DirectoryEntry::DirectoryEntry() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void DirectoryEntry::InitAsDefaultInstance() { + stbuf_ = const_cast< ::xtreemfs::pbrpc::Stat*>(&::xtreemfs::pbrpc::Stat::default_instance()); +} + +DirectoryEntry::DirectoryEntry(const DirectoryEntry& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void DirectoryEntry::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + stbuf_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DirectoryEntry::~DirectoryEntry() { + SharedDtor(); +} + +void DirectoryEntry::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + delete stbuf_; + } +} + +void DirectoryEntry::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DirectoryEntry::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DirectoryEntry_descriptor_; +} + +const DirectoryEntry& DirectoryEntry::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +DirectoryEntry* DirectoryEntry::default_instance_ = NULL; + +DirectoryEntry* DirectoryEntry::New() const { + return new DirectoryEntry; +} + +void DirectoryEntry::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + if (has_stbuf()) { + if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool DirectoryEntry::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_stbuf; + break; + } + + // optional .xtreemfs.pbrpc.Stat stbuf = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_stbuf: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_stbuf())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void DirectoryEntry::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + // optional .xtreemfs.pbrpc.Stat stbuf = 2; + if (has_stbuf()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->stbuf(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* DirectoryEntry::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional .xtreemfs.pbrpc.Stat stbuf = 2; + if (has_stbuf()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->stbuf(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int DirectoryEntry::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional .xtreemfs.pbrpc.Stat stbuf = 2; + if (has_stbuf()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->stbuf()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DirectoryEntry::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const DirectoryEntry* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void DirectoryEntry::MergeFrom(const DirectoryEntry& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_stbuf()) { + mutable_stbuf()->::xtreemfs::pbrpc::Stat::MergeFrom(from.stbuf()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void DirectoryEntry::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DirectoryEntry::CopyFrom(const DirectoryEntry& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DirectoryEntry::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_stbuf()) { + if (!this->stbuf().IsInitialized()) return false; + } + return true; +} + +void DirectoryEntry::Swap(DirectoryEntry* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(stbuf_, other->stbuf_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata DirectoryEntry::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DirectoryEntry_descriptor_; + metadata.reflection = DirectoryEntry_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DirectoryEntries::kEntriesFieldNumber; +#endif // !_MSC_VER + +DirectoryEntries::DirectoryEntries() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void DirectoryEntries::InitAsDefaultInstance() { +} + +DirectoryEntries::DirectoryEntries(const DirectoryEntries& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void DirectoryEntries::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DirectoryEntries::~DirectoryEntries() { + SharedDtor(); +} + +void DirectoryEntries::SharedDtor() { + if (this != default_instance_) { + } +} + +void DirectoryEntries::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* DirectoryEntries::descriptor() { + protobuf_AssignDescriptorsOnce(); + return DirectoryEntries_descriptor_; +} + +const DirectoryEntries& DirectoryEntries::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +DirectoryEntries* DirectoryEntries::default_instance_ = NULL; + +DirectoryEntries* DirectoryEntries::New() const { + return new DirectoryEntries; +} + +void DirectoryEntries::Clear() { + entries_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool DirectoryEntries::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .xtreemfs.pbrpc.DirectoryEntry entries = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_entries: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_entries())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_entries; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void DirectoryEntries::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .xtreemfs.pbrpc.DirectoryEntry entries = 1; + for (int i = 0; i < this->entries_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->entries(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* DirectoryEntries::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .xtreemfs.pbrpc.DirectoryEntry entries = 1; + for (int i = 0; i < this->entries_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->entries(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int DirectoryEntries::ByteSize() const { + int total_size = 0; + + // repeated .xtreemfs.pbrpc.DirectoryEntry entries = 1; + total_size += 1 * this->entries_size(); + for (int i = 0; i < this->entries_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->entries(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DirectoryEntries::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const DirectoryEntries* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void DirectoryEntries::MergeFrom(const DirectoryEntries& from) { + GOOGLE_CHECK_NE(&from, this); + entries_.MergeFrom(from.entries_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void DirectoryEntries::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DirectoryEntries::CopyFrom(const DirectoryEntries& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DirectoryEntries::IsInitialized() const { + + for (int i = 0; i < entries_size(); i++) { + if (!this->entries(i).IsInitialized()) return false; + } + return true; +} + +void DirectoryEntries::Swap(DirectoryEntries* other) { + if (other != this) { + entries_.Swap(&other->entries_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata DirectoryEntries::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = DirectoryEntries_descriptor_; + metadata.reflection = DirectoryEntries_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int XAttr::kNameFieldNumber; +const int XAttr::kValueFieldNumber; +const int XAttr::kValueBytesStringFieldNumber; +#endif // !_MSC_VER + +XAttr::XAttr() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void XAttr::InitAsDefaultInstance() { +} + +XAttr::XAttr(const XAttr& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void XAttr::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +XAttr::~XAttr() { + SharedDtor(); +} + +void XAttr::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + delete value_bytes_string_; + } + if (this != default_instance_) { + } +} + +void XAttr::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* XAttr::descriptor() { + protobuf_AssignDescriptorsOnce(); + return XAttr_descriptor_; +} + +const XAttr& XAttr::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +XAttr* XAttr::default_instance_ = NULL; + +XAttr* XAttr::New() const { + return new XAttr; +} + +void XAttr::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + if (has_value()) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + } + if (has_value_bytes_string()) { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + value_bytes_string_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool XAttr::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_value; + break; + } + + // optional string value = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_value())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_value_bytes_string; + break; + } + + // optional bytes value_bytes_string = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_value_bytes_string: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_value_bytes_string())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void XAttr::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + // optional string value = 2; + if (has_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->value(), output); + } + + // optional bytes value_bytes_string = 3; + if (has_value_bytes_string()) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 3, this->value_bytes_string(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* XAttr::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional string value = 2; + if (has_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->value(), target); + } + + // optional bytes value_bytes_string = 3; + if (has_value_bytes_string()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 3, this->value_bytes_string(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int XAttr::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string value = 2; + if (has_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->value()); + } + + // optional bytes value_bytes_string = 3; + if (has_value_bytes_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->value_bytes_string()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void XAttr::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const XAttr* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void XAttr::MergeFrom(const XAttr& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_value()) { + set_value(from.value()); + } + if (from.has_value_bytes_string()) { + set_value_bytes_string(from.value_bytes_string()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void XAttr::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void XAttr::CopyFrom(const XAttr& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool XAttr::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void XAttr::Swap(XAttr* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(value_, other->value_); + std::swap(value_bytes_string_, other->value_bytes_string_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata XAttr::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = XAttr_descriptor_; + metadata.reflection = XAttr_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Volume::kAccessControlPolicyFieldNumber; +const int Volume::kDefaultStripingPolicyFieldNumber; +const int Volume::kIdFieldNumber; +const int Volume::kModeFieldNumber; +const int Volume::kNameFieldNumber; +const int Volume::kOwnerGroupIdFieldNumber; +const int Volume::kOwnerUserIdFieldNumber; +const int Volume::kAttrsFieldNumber; +const int Volume::kQuotaFieldNumber; +#endif // !_MSC_VER + +Volume::Volume() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Volume::InitAsDefaultInstance() { + default_striping_policy_ = const_cast< ::xtreemfs::pbrpc::StripingPolicy*>(&::xtreemfs::pbrpc::StripingPolicy::default_instance()); +} + +Volume::Volume(const Volume& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Volume::SharedCtor() { + _cached_size_ = 0; + access_control_policy_ = 1; + default_striping_policy_ = NULL; + id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + mode_ = 0u; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + owner_group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + owner_user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + quota_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Volume::~Volume() { + SharedDtor(); +} + +void Volume::SharedDtor() { + if (id_ != &::google::protobuf::internal::kEmptyString) { + delete id_; + } + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) { + delete owner_group_id_; + } + if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) { + delete owner_user_id_; + } + if (this != default_instance_) { + delete default_striping_policy_; + } +} + +void Volume::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Volume::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Volume_descriptor_; +} + +const Volume& Volume::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +Volume* Volume::default_instance_ = NULL; + +Volume* Volume::New() const { + return new Volume; +} + +void Volume::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + access_control_policy_ = 1; + if (has_default_striping_policy()) { + if (default_striping_policy_ != NULL) default_striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear(); + } + if (has_id()) { + if (id_ != &::google::protobuf::internal::kEmptyString) { + id_->clear(); + } + } + mode_ = 0u; + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + if (has_owner_group_id()) { + if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) { + owner_group_id_->clear(); + } + } + if (has_owner_user_id()) { + if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) { + owner_user_id_->clear(); + } + } + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + quota_ = GOOGLE_ULONGLONG(0); + } + attrs_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Volume::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::AccessControlPolicyType_IsValid(value)) { + set_access_control_policy(static_cast< ::xtreemfs::pbrpc::AccessControlPolicyType >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_default_striping_policy; + break; + } + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_default_striping_policy: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_default_striping_policy())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_id; + break; + } + + // required string id = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->id().data(), this->id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_mode; + break; + } + + // required fixed32 mode = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_mode: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &mode_))); + set_has_mode(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_name; + break; + } + + // required string name = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_owner_group_id; + break; + } + + // required string owner_group_id = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_owner_group_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_owner_group_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_group_id().data(), this->owner_group_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(58)) goto parse_owner_user_id; + break; + } + + // required string owner_user_id = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_owner_user_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_owner_user_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_user_id().data(), this->owner_user_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_attrs; + break; + } + + // repeated .xtreemfs.pbrpc.KeyValuePair attrs = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_attrs: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_attrs())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_attrs; + if (input->ExpectTag(73)) goto parse_quota; + break; + } + + // optional fixed64 quota = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_quota: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, "a_))); + set_has_quota(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Volume::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1; + if (has_access_control_policy()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->access_control_policy(), output); + } + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 2; + if (has_default_striping_policy()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->default_striping_policy(), output); + } + + // required string id = 3; + if (has_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->id().data(), this->id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->id(), output); + } + + // required fixed32 mode = 4; + if (has_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->mode(), output); + } + + // required string name = 5; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 5, this->name(), output); + } + + // required string owner_group_id = 6; + if (has_owner_group_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_group_id().data(), this->owner_group_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 6, this->owner_group_id(), output); + } + + // required string owner_user_id = 7; + if (has_owner_user_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_user_id().data(), this->owner_user_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 7, this->owner_user_id(), output); + } + + // repeated .xtreemfs.pbrpc.KeyValuePair attrs = 8; + for (int i = 0; i < this->attrs_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->attrs(i), output); + } + + // optional fixed64 quota = 9; + if (has_quota()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(9, this->quota(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Volume::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1; + if (has_access_control_policy()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->access_control_policy(), target); + } + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 2; + if (has_default_striping_policy()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->default_striping_policy(), target); + } + + // required string id = 3; + if (has_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->id().data(), this->id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->id(), target); + } + + // required fixed32 mode = 4; + if (has_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->mode(), target); + } + + // required string name = 5; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->name(), target); + } + + // required string owner_group_id = 6; + if (has_owner_group_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_group_id().data(), this->owner_group_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->owner_group_id(), target); + } + + // required string owner_user_id = 7; + if (has_owner_user_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_user_id().data(), this->owner_user_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 7, this->owner_user_id(), target); + } + + // repeated .xtreemfs.pbrpc.KeyValuePair attrs = 8; + for (int i = 0; i < this->attrs_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 8, this->attrs(i), target); + } + + // optional fixed64 quota = 9; + if (has_quota()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(9, this->quota(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Volume::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1; + if (has_access_control_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->access_control_policy()); + } + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 2; + if (has_default_striping_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->default_striping_policy()); + } + + // required string id = 3; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->id()); + } + + // required fixed32 mode = 4; + if (has_mode()) { + total_size += 1 + 4; + } + + // required string name = 5; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // required string owner_group_id = 6; + if (has_owner_group_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->owner_group_id()); + } + + // required string owner_user_id = 7; + if (has_owner_user_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->owner_user_id()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional fixed64 quota = 9; + if (has_quota()) { + total_size += 1 + 8; + } + + } + // repeated .xtreemfs.pbrpc.KeyValuePair attrs = 8; + total_size += 1 * this->attrs_size(); + for (int i = 0; i < this->attrs_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->attrs(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Volume::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Volume* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Volume::MergeFrom(const Volume& from) { + GOOGLE_CHECK_NE(&from, this); + attrs_.MergeFrom(from.attrs_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_access_control_policy()) { + set_access_control_policy(from.access_control_policy()); + } + if (from.has_default_striping_policy()) { + mutable_default_striping_policy()->::xtreemfs::pbrpc::StripingPolicy::MergeFrom(from.default_striping_policy()); + } + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_mode()) { + set_mode(from.mode()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_owner_group_id()) { + set_owner_group_id(from.owner_group_id()); + } + if (from.has_owner_user_id()) { + set_owner_user_id(from.owner_user_id()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_quota()) { + set_quota(from.quota()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Volume::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Volume::CopyFrom(const Volume& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Volume::IsInitialized() const { + if ((_has_bits_[0] & 0x0000007f) != 0x0000007f) return false; + + if (has_default_striping_policy()) { + if (!this->default_striping_policy().IsInitialized()) return false; + } + for (int i = 0; i < attrs_size(); i++) { + if (!this->attrs(i).IsInitialized()) return false; + } + return true; +} + +void Volume::Swap(Volume* other) { + if (other != this) { + std::swap(access_control_policy_, other->access_control_policy_); + std::swap(default_striping_policy_, other->default_striping_policy_); + std::swap(id_, other->id_); + std::swap(mode_, other->mode_); + std::swap(name_, other->name_); + std::swap(owner_group_id_, other->owner_group_id_); + std::swap(owner_user_id_, other->owner_user_id_); + attrs_.Swap(&other->attrs_); + std::swap(quota_, other->quota_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Volume::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Volume_descriptor_; + metadata.reflection = Volume_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Volumes::kVolumesFieldNumber; +#endif // !_MSC_VER + +Volumes::Volumes() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Volumes::InitAsDefaultInstance() { +} + +Volumes::Volumes(const Volumes& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Volumes::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Volumes::~Volumes() { + SharedDtor(); +} + +void Volumes::SharedDtor() { + if (this != default_instance_) { + } +} + +void Volumes::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Volumes::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Volumes_descriptor_; +} + +const Volumes& Volumes::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +Volumes* Volumes::default_instance_ = NULL; + +Volumes* Volumes::New() const { + return new Volumes; +} + +void Volumes::Clear() { + volumes_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Volumes::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .xtreemfs.pbrpc.Volume volumes = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_volumes: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_volumes())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_volumes; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Volumes::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .xtreemfs.pbrpc.Volume volumes = 1; + for (int i = 0; i < this->volumes_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->volumes(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Volumes::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .xtreemfs.pbrpc.Volume volumes = 1; + for (int i = 0; i < this->volumes_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->volumes(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Volumes::ByteSize() const { + int total_size = 0; + + // repeated .xtreemfs.pbrpc.Volume volumes = 1; + total_size += 1 * this->volumes_size(); + for (int i = 0; i < this->volumes_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->volumes(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Volumes::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Volumes* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Volumes::MergeFrom(const Volumes& from) { + GOOGLE_CHECK_NE(&from, this); + volumes_.MergeFrom(from.volumes_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Volumes::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Volumes::CopyFrom(const Volumes& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Volumes::IsInitialized() const { + + for (int i = 0; i < volumes_size(); i++) { + if (!this->volumes(i).IsInitialized()) return false; + } + return true; +} + +void Volumes::Swap(Volumes* other) { + if (other != this) { + volumes_.Swap(&other->volumes_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Volumes::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Volumes_descriptor_; + metadata.reflection = Volumes_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int StatVFS::kBsizeFieldNumber; +const int StatVFS::kBavailFieldNumber; +const int StatVFS::kBfreeFieldNumber; +const int StatVFS::kBlocksFieldNumber; +const int StatVFS::kFsidFieldNumber; +const int StatVFS::kNamemaxFieldNumber; +const int StatVFS::kAccessControlPolicyFieldNumber; +const int StatVFS::kDefaultStripingPolicyFieldNumber; +const int StatVFS::kEtagFieldNumber; +const int StatVFS::kModeFieldNumber; +const int StatVFS::kNameFieldNumber; +const int StatVFS::kOwnerGroupIdFieldNumber; +const int StatVFS::kOwnerUserIdFieldNumber; +#endif // !_MSC_VER + +StatVFS::StatVFS() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void StatVFS::InitAsDefaultInstance() { + default_striping_policy_ = const_cast< ::xtreemfs::pbrpc::StripingPolicy*>(&::xtreemfs::pbrpc::StripingPolicy::default_instance()); +} + +StatVFS::StatVFS(const StatVFS& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void StatVFS::SharedCtor() { + _cached_size_ = 0; + bsize_ = 0u; + bavail_ = GOOGLE_ULONGLONG(0); + bfree_ = GOOGLE_ULONGLONG(0); + blocks_ = GOOGLE_ULONGLONG(0); + fsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + namemax_ = 0u; + access_control_policy_ = 1; + default_striping_policy_ = NULL; + etag_ = GOOGLE_ULONGLONG(0); + mode_ = 0u; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + owner_group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + owner_user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +StatVFS::~StatVFS() { + SharedDtor(); +} + +void StatVFS::SharedDtor() { + if (fsid_ != &::google::protobuf::internal::kEmptyString) { + delete fsid_; + } + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) { + delete owner_group_id_; + } + if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) { + delete owner_user_id_; + } + if (this != default_instance_) { + delete default_striping_policy_; + } +} + +void StatVFS::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* StatVFS::descriptor() { + protobuf_AssignDescriptorsOnce(); + return StatVFS_descriptor_; +} + +const StatVFS& StatVFS::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +StatVFS* StatVFS::default_instance_ = NULL; + +StatVFS* StatVFS::New() const { + return new StatVFS; +} + +void StatVFS::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + bsize_ = 0u; + bavail_ = GOOGLE_ULONGLONG(0); + bfree_ = GOOGLE_ULONGLONG(0); + blocks_ = GOOGLE_ULONGLONG(0); + if (has_fsid()) { + if (fsid_ != &::google::protobuf::internal::kEmptyString) { + fsid_->clear(); + } + } + namemax_ = 0u; + access_control_policy_ = 1; + if (has_default_striping_policy()) { + if (default_striping_policy_ != NULL) default_striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear(); + } + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + etag_ = GOOGLE_ULONGLONG(0); + mode_ = 0u; + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + if (has_owner_group_id()) { + if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) { + owner_group_id_->clear(); + } + } + if (has_owner_user_id()) { + if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) { + owner_user_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool StatVFS::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 bsize = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &bsize_))); + set_has_bsize(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_bavail; + break; + } + + // required fixed64 bavail = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_bavail: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &bavail_))); + set_has_bavail(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_blocks; + break; + } + + // required fixed64 blocks = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_blocks: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &blocks_))); + set_has_blocks(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_fsid; + break; + } + + // required string fsid = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_fsid: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_fsid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->fsid().data(), this->fsid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_namemax; + break; + } + + // required fixed32 namemax = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_namemax: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &namemax_))); + set_has_namemax(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_access_control_policy; + break; + } + + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_access_control_policy: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::AccessControlPolicyType_IsValid(value)) { + set_access_control_policy(static_cast< ::xtreemfs::pbrpc::AccessControlPolicyType >(value)); + } else { + mutable_unknown_fields()->AddVarint(6, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(58)) goto parse_default_striping_policy; + break; + } + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_default_striping_policy: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_default_striping_policy())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(65)) goto parse_etag; + break; + } + + // required fixed64 etag = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_etag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &etag_))); + set_has_etag(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(77)) goto parse_mode; + break; + } + + // required fixed32 mode = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_mode: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &mode_))); + set_has_mode(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(82)) goto parse_name; + break; + } + + // required string name = 10; + case 10: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(90)) goto parse_owner_group_id; + break; + } + + // required string owner_group_id = 11; + case 11: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_owner_group_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_owner_group_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_group_id().data(), this->owner_group_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(98)) goto parse_owner_user_id; + break; + } + + // required string owner_user_id = 12; + case 12: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_owner_user_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_owner_user_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_user_id().data(), this->owner_user_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(105)) goto parse_bfree; + break; + } + + // optional fixed64 bfree = 13; + case 13: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_bfree: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &bfree_))); + set_has_bfree(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void StatVFS::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 bsize = 1; + if (has_bsize()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->bsize(), output); + } + + // required fixed64 bavail = 2; + if (has_bavail()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->bavail(), output); + } + + // required fixed64 blocks = 3; + if (has_blocks()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->blocks(), output); + } + + // required string fsid = 4; + if (has_fsid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->fsid().data(), this->fsid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->fsid(), output); + } + + // required fixed32 namemax = 5; + if (has_namemax()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->namemax(), output); + } + + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6; + if (has_access_control_policy()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->access_control_policy(), output); + } + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 7; + if (has_default_striping_policy()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->default_striping_policy(), output); + } + + // required fixed64 etag = 8; + if (has_etag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(8, this->etag(), output); + } + + // required fixed32 mode = 9; + if (has_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(9, this->mode(), output); + } + + // required string name = 10; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 10, this->name(), output); + } + + // required string owner_group_id = 11; + if (has_owner_group_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_group_id().data(), this->owner_group_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 11, this->owner_group_id(), output); + } + + // required string owner_user_id = 12; + if (has_owner_user_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_user_id().data(), this->owner_user_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 12, this->owner_user_id(), output); + } + + // optional fixed64 bfree = 13; + if (has_bfree()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(13, this->bfree(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* StatVFS::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 bsize = 1; + if (has_bsize()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->bsize(), target); + } + + // required fixed64 bavail = 2; + if (has_bavail()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->bavail(), target); + } + + // required fixed64 blocks = 3; + if (has_blocks()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->blocks(), target); + } + + // required string fsid = 4; + if (has_fsid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->fsid().data(), this->fsid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->fsid(), target); + } + + // required fixed32 namemax = 5; + if (has_namemax()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->namemax(), target); + } + + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6; + if (has_access_control_policy()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->access_control_policy(), target); + } + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 7; + if (has_default_striping_policy()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 7, this->default_striping_policy(), target); + } + + // required fixed64 etag = 8; + if (has_etag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(8, this->etag(), target); + } + + // required fixed32 mode = 9; + if (has_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(9, this->mode(), target); + } + + // required string name = 10; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 10, this->name(), target); + } + + // required string owner_group_id = 11; + if (has_owner_group_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_group_id().data(), this->owner_group_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 11, this->owner_group_id(), target); + } + + // required string owner_user_id = 12; + if (has_owner_user_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->owner_user_id().data(), this->owner_user_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 12, this->owner_user_id(), target); + } + + // optional fixed64 bfree = 13; + if (has_bfree()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(13, this->bfree(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int StatVFS::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 bsize = 1; + if (has_bsize()) { + total_size += 1 + 4; + } + + // required fixed64 bavail = 2; + if (has_bavail()) { + total_size += 1 + 8; + } + + // optional fixed64 bfree = 13; + if (has_bfree()) { + total_size += 1 + 8; + } + + // required fixed64 blocks = 3; + if (has_blocks()) { + total_size += 1 + 8; + } + + // required string fsid = 4; + if (has_fsid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->fsid()); + } + + // required fixed32 namemax = 5; + if (has_namemax()) { + total_size += 1 + 4; + } + + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6; + if (has_access_control_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->access_control_policy()); + } + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 7; + if (has_default_striping_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->default_striping_policy()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // required fixed64 etag = 8; + if (has_etag()) { + total_size += 1 + 8; + } + + // required fixed32 mode = 9; + if (has_mode()) { + total_size += 1 + 4; + } + + // required string name = 10; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // required string owner_group_id = 11; + if (has_owner_group_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->owner_group_id()); + } + + // required string owner_user_id = 12; + if (has_owner_user_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->owner_user_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void StatVFS::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const StatVFS* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void StatVFS::MergeFrom(const StatVFS& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_bsize()) { + set_bsize(from.bsize()); + } + if (from.has_bavail()) { + set_bavail(from.bavail()); + } + if (from.has_bfree()) { + set_bfree(from.bfree()); + } + if (from.has_blocks()) { + set_blocks(from.blocks()); + } + if (from.has_fsid()) { + set_fsid(from.fsid()); + } + if (from.has_namemax()) { + set_namemax(from.namemax()); + } + if (from.has_access_control_policy()) { + set_access_control_policy(from.access_control_policy()); + } + if (from.has_default_striping_policy()) { + mutable_default_striping_policy()->::xtreemfs::pbrpc::StripingPolicy::MergeFrom(from.default_striping_policy()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_etag()) { + set_etag(from.etag()); + } + if (from.has_mode()) { + set_mode(from.mode()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_owner_group_id()) { + set_owner_group_id(from.owner_group_id()); + } + if (from.has_owner_user_id()) { + set_owner_user_id(from.owner_user_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void StatVFS::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void StatVFS::CopyFrom(const StatVFS& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StatVFS::IsInitialized() const { + if ((_has_bits_[0] & 0x00001ffb) != 0x00001ffb) return false; + + if (has_default_striping_policy()) { + if (!this->default_striping_policy().IsInitialized()) return false; + } + return true; +} + +void StatVFS::Swap(StatVFS* other) { + if (other != this) { + std::swap(bsize_, other->bsize_); + std::swap(bavail_, other->bavail_); + std::swap(bfree_, other->bfree_); + std::swap(blocks_, other->blocks_); + std::swap(fsid_, other->fsid_); + std::swap(namemax_, other->namemax_); + std::swap(access_control_policy_, other->access_control_policy_); + std::swap(default_striping_policy_, other->default_striping_policy_); + std::swap(etag_, other->etag_); + std::swap(mode_, other->mode_); + std::swap(name_, other->name_); + std::swap(owner_group_id_, other->owner_group_id_); + std::swap(owner_user_id_, other->owner_user_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata StatVFS::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = StatVFS_descriptor_; + metadata.reflection = StatVFS_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int fsetattrRequest::kStbufFieldNumber; +const int fsetattrRequest::kToSetFieldNumber; +const int fsetattrRequest::kCapFieldNumber; +#endif // !_MSC_VER + +fsetattrRequest::fsetattrRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void fsetattrRequest::InitAsDefaultInstance() { + stbuf_ = const_cast< ::xtreemfs::pbrpc::Stat*>(&::xtreemfs::pbrpc::Stat::default_instance()); + cap_ = const_cast< ::xtreemfs::pbrpc::XCap*>(&::xtreemfs::pbrpc::XCap::default_instance()); +} + +fsetattrRequest::fsetattrRequest(const fsetattrRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void fsetattrRequest::SharedCtor() { + _cached_size_ = 0; + stbuf_ = NULL; + to_set_ = 0u; + cap_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +fsetattrRequest::~fsetattrRequest() { + SharedDtor(); +} + +void fsetattrRequest::SharedDtor() { + if (this != default_instance_) { + delete stbuf_; + delete cap_; + } +} + +void fsetattrRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* fsetattrRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return fsetattrRequest_descriptor_; +} + +const fsetattrRequest& fsetattrRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +fsetattrRequest* fsetattrRequest::default_instance_ = NULL; + +fsetattrRequest* fsetattrRequest::New() const { + return new fsetattrRequest; +} + +void fsetattrRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_stbuf()) { + if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear(); + } + to_set_ = 0u; + if (has_cap()) { + if (cap_ != NULL) cap_->::xtreemfs::pbrpc::XCap::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool fsetattrRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.Stat stbuf = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_stbuf())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_to_set; + break; + } + + // required fixed32 to_set = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_to_set: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &to_set_))); + set_has_to_set(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_cap; + break; + } + + // required .xtreemfs.pbrpc.XCap cap = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_cap: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_cap())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void fsetattrRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.Stat stbuf = 1; + if (has_stbuf()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->stbuf(), output); + } + + // required fixed32 to_set = 2; + if (has_to_set()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->to_set(), output); + } + + // required .xtreemfs.pbrpc.XCap cap = 3; + if (has_cap()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->cap(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* fsetattrRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.Stat stbuf = 1; + if (has_stbuf()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->stbuf(), target); + } + + // required fixed32 to_set = 2; + if (has_to_set()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->to_set(), target); + } + + // required .xtreemfs.pbrpc.XCap cap = 3; + if (has_cap()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->cap(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int fsetattrRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.Stat stbuf = 1; + if (has_stbuf()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->stbuf()); + } + + // required fixed32 to_set = 2; + if (has_to_set()) { + total_size += 1 + 4; + } + + // required .xtreemfs.pbrpc.XCap cap = 3; + if (has_cap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cap()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void fsetattrRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const fsetattrRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void fsetattrRequest::MergeFrom(const fsetattrRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_stbuf()) { + mutable_stbuf()->::xtreemfs::pbrpc::Stat::MergeFrom(from.stbuf()); + } + if (from.has_to_set()) { + set_to_set(from.to_set()); + } + if (from.has_cap()) { + mutable_cap()->::xtreemfs::pbrpc::XCap::MergeFrom(from.cap()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void fsetattrRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void fsetattrRequest::CopyFrom(const fsetattrRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool fsetattrRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + if (has_stbuf()) { + if (!this->stbuf().IsInitialized()) return false; + } + if (has_cap()) { + if (!this->cap().IsInitialized()) return false; + } + return true; +} + +void fsetattrRequest::Swap(fsetattrRequest* other) { + if (other != this) { + std::swap(stbuf_, other->stbuf_); + std::swap(to_set_, other->to_set_); + std::swap(cap_, other->cap_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata fsetattrRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = fsetattrRequest_descriptor_; + metadata.reflection = fsetattrRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int getattrRequest::kVolumeNameFieldNumber; +const int getattrRequest::kPathFieldNumber; +const int getattrRequest::kKnownEtagFieldNumber; +#endif // !_MSC_VER + +getattrRequest::getattrRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void getattrRequest::InitAsDefaultInstance() { +} + +getattrRequest::getattrRequest(const getattrRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void getattrRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + known_etag_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +getattrRequest::~getattrRequest() { + SharedDtor(); +} + +void getattrRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void getattrRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* getattrRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return getattrRequest_descriptor_; +} + +const getattrRequest& getattrRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +getattrRequest* getattrRequest::default_instance_ = NULL; + +getattrRequest* getattrRequest::New() const { + return new getattrRequest; +} + +void getattrRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + known_etag_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool getattrRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_known_etag; + break; + } + + // required fixed64 known_etag = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_known_etag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &known_etag_))); + set_has_known_etag(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void getattrRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required fixed64 known_etag = 3; + if (has_known_etag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->known_etag(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* getattrRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required fixed64 known_etag = 3; + if (has_known_etag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->known_etag(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int getattrRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required fixed64 known_etag = 3; + if (has_known_etag()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void getattrRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const getattrRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void getattrRequest::MergeFrom(const getattrRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_known_etag()) { + set_known_etag(from.known_etag()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void getattrRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void getattrRequest::CopyFrom(const getattrRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool getattrRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void getattrRequest::Swap(getattrRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(known_etag_, other->known_etag_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata getattrRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = getattrRequest_descriptor_; + metadata.reflection = getattrRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int getattrResponse::kStbufFieldNumber; +#endif // !_MSC_VER + +getattrResponse::getattrResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void getattrResponse::InitAsDefaultInstance() { + stbuf_ = const_cast< ::xtreemfs::pbrpc::Stat*>(&::xtreemfs::pbrpc::Stat::default_instance()); +} + +getattrResponse::getattrResponse(const getattrResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void getattrResponse::SharedCtor() { + _cached_size_ = 0; + stbuf_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +getattrResponse::~getattrResponse() { + SharedDtor(); +} + +void getattrResponse::SharedDtor() { + if (this != default_instance_) { + delete stbuf_; + } +} + +void getattrResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* getattrResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return getattrResponse_descriptor_; +} + +const getattrResponse& getattrResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +getattrResponse* getattrResponse::default_instance_ = NULL; + +getattrResponse* getattrResponse::New() const { + return new getattrResponse; +} + +void getattrResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_stbuf()) { + if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool getattrResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .xtreemfs.pbrpc.Stat stbuf = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_stbuf())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void getattrResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .xtreemfs.pbrpc.Stat stbuf = 1; + if (has_stbuf()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->stbuf(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* getattrResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .xtreemfs.pbrpc.Stat stbuf = 1; + if (has_stbuf()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->stbuf(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int getattrResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .xtreemfs.pbrpc.Stat stbuf = 1; + if (has_stbuf()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->stbuf()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void getattrResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const getattrResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void getattrResponse::MergeFrom(const getattrResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_stbuf()) { + mutable_stbuf()->::xtreemfs::pbrpc::Stat::MergeFrom(from.stbuf()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void getattrResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void getattrResponse::CopyFrom(const getattrResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool getattrResponse::IsInitialized() const { + + if (has_stbuf()) { + if (!this->stbuf().IsInitialized()) return false; + } + return true; +} + +void getattrResponse::Swap(getattrResponse* other) { + if (other != this) { + std::swap(stbuf_, other->stbuf_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata getattrResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = getattrResponse_descriptor_; + metadata.reflection = getattrResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int getxattrRequest::kVolumeNameFieldNumber; +const int getxattrRequest::kPathFieldNumber; +const int getxattrRequest::kNameFieldNumber; +#endif // !_MSC_VER + +getxattrRequest::getxattrRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void getxattrRequest::InitAsDefaultInstance() { +} + +getxattrRequest::getxattrRequest(const getxattrRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void getxattrRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +getxattrRequest::~getxattrRequest() { + SharedDtor(); +} + +void getxattrRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void getxattrRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* getxattrRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return getxattrRequest_descriptor_; +} + +const getxattrRequest& getxattrRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +getxattrRequest* getxattrRequest::default_instance_ = NULL; + +getxattrRequest* getxattrRequest::New() const { + return new getxattrRequest; +} + +void getxattrRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool getxattrRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_name; + break; + } + + // required string name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void getxattrRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required string name = 3; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* getxattrRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required string name = 3; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int getxattrRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void getxattrRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const getxattrRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void getxattrRequest::MergeFrom(const getxattrRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_name()) { + set_name(from.name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void getxattrRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void getxattrRequest::CopyFrom(const getxattrRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool getxattrRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void getxattrRequest::Swap(getxattrRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(name_, other->name_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata getxattrRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = getxattrRequest_descriptor_; + metadata.reflection = getxattrRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int getxattrResponse::kValueFieldNumber; +const int getxattrResponse::kValueBytesStringFieldNumber; +#endif // !_MSC_VER + +getxattrResponse::getxattrResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void getxattrResponse::InitAsDefaultInstance() { +} + +getxattrResponse::getxattrResponse(const getxattrResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void getxattrResponse::SharedCtor() { + _cached_size_ = 0; + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +getxattrResponse::~getxattrResponse() { + SharedDtor(); +} + +void getxattrResponse::SharedDtor() { + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + delete value_bytes_string_; + } + if (this != default_instance_) { + } +} + +void getxattrResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* getxattrResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return getxattrResponse_descriptor_; +} + +const getxattrResponse& getxattrResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +getxattrResponse* getxattrResponse::default_instance_ = NULL; + +getxattrResponse* getxattrResponse::New() const { + return new getxattrResponse; +} + +void getxattrResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_value()) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + } + if (has_value_bytes_string()) { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + value_bytes_string_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool getxattrResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string value = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_value())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_value_bytes_string; + break; + } + + // optional bytes value_bytes_string = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_value_bytes_string: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_value_bytes_string())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void getxattrResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string value = 1; + if (has_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->value(), output); + } + + // optional bytes value_bytes_string = 2; + if (has_value_bytes_string()) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 2, this->value_bytes_string(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* getxattrResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string value = 1; + if (has_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->value(), target); + } + + // optional bytes value_bytes_string = 2; + if (has_value_bytes_string()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 2, this->value_bytes_string(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int getxattrResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string value = 1; + if (has_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->value()); + } + + // optional bytes value_bytes_string = 2; + if (has_value_bytes_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->value_bytes_string()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void getxattrResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const getxattrResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void getxattrResponse::MergeFrom(const getxattrResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_value()) { + set_value(from.value()); + } + if (from.has_value_bytes_string()) { + set_value_bytes_string(from.value_bytes_string()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void getxattrResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void getxattrResponse::CopyFrom(const getxattrResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool getxattrResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void getxattrResponse::Swap(getxattrResponse* other) { + if (other != this) { + std::swap(value_, other->value_); + std::swap(value_bytes_string_, other->value_bytes_string_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata getxattrResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = getxattrResponse_descriptor_; + metadata.reflection = getxattrResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int linkRequest::kVolumeNameFieldNumber; +const int linkRequest::kTargetPathFieldNumber; +const int linkRequest::kLinkPathFieldNumber; +#endif // !_MSC_VER + +linkRequest::linkRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void linkRequest::InitAsDefaultInstance() { +} + +linkRequest::linkRequest(const linkRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void linkRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + link_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +linkRequest::~linkRequest() { + SharedDtor(); +} + +void linkRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + delete target_path_; + } + if (link_path_ != &::google::protobuf::internal::kEmptyString) { + delete link_path_; + } + if (this != default_instance_) { + } +} + +void linkRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* linkRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return linkRequest_descriptor_; +} + +const linkRequest& linkRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +linkRequest* linkRequest::default_instance_ = NULL; + +linkRequest* linkRequest::New() const { + return new linkRequest; +} + +void linkRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_target_path()) { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + target_path_->clear(); + } + } + if (has_link_path()) { + if (link_path_ != &::google::protobuf::internal::kEmptyString) { + link_path_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool linkRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_target_path; + break; + } + + // required string target_path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_target_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_target_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_link_path; + break; + } + + // required string link_path = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_link_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_link_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_path().data(), this->link_path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void linkRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string target_path = 2; + if (has_target_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->target_path(), output); + } + + // required string link_path = 3; + if (has_link_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_path().data(), this->link_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->link_path(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* linkRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string target_path = 2; + if (has_target_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->target_path(), target); + } + + // required string link_path = 3; + if (has_link_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_path().data(), this->link_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->link_path(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int linkRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string target_path = 2; + if (has_target_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->target_path()); + } + + // required string link_path = 3; + if (has_link_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->link_path()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void linkRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const linkRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void linkRequest::MergeFrom(const linkRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_target_path()) { + set_target_path(from.target_path()); + } + if (from.has_link_path()) { + set_link_path(from.link_path()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void linkRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void linkRequest::CopyFrom(const linkRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool linkRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void linkRequest::Swap(linkRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(target_path_, other->target_path_); + std::swap(link_path_, other->link_path_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata linkRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = linkRequest_descriptor_; + metadata.reflection = linkRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int listxattrRequest::kVolumeNameFieldNumber; +const int listxattrRequest::kPathFieldNumber; +const int listxattrRequest::kNamesOnlyFieldNumber; +#endif // !_MSC_VER + +listxattrRequest::listxattrRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void listxattrRequest::InitAsDefaultInstance() { +} + +listxattrRequest::listxattrRequest(const listxattrRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void listxattrRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + names_only_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +listxattrRequest::~listxattrRequest() { + SharedDtor(); +} + +void listxattrRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void listxattrRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* listxattrRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return listxattrRequest_descriptor_; +} + +const listxattrRequest& listxattrRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +listxattrRequest* listxattrRequest::default_instance_ = NULL; + +listxattrRequest* listxattrRequest::New() const { + return new listxattrRequest; +} + +void listxattrRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + names_only_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool listxattrRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_names_only; + break; + } + + // required bool names_only = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_names_only: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &names_only_))); + set_has_names_only(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void listxattrRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required bool names_only = 3; + if (has_names_only()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->names_only(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* listxattrRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required bool names_only = 3; + if (has_names_only()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->names_only(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int listxattrRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required bool names_only = 3; + if (has_names_only()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void listxattrRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const listxattrRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void listxattrRequest::MergeFrom(const listxattrRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_names_only()) { + set_names_only(from.names_only()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void listxattrRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void listxattrRequest::CopyFrom(const listxattrRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool listxattrRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void listxattrRequest::Swap(listxattrRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(names_only_, other->names_only_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata listxattrRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = listxattrRequest_descriptor_; + metadata.reflection = listxattrRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int listxattrResponse::kXattrsFieldNumber; +#endif // !_MSC_VER + +listxattrResponse::listxattrResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void listxattrResponse::InitAsDefaultInstance() { +} + +listxattrResponse::listxattrResponse(const listxattrResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void listxattrResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +listxattrResponse::~listxattrResponse() { + SharedDtor(); +} + +void listxattrResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void listxattrResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* listxattrResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return listxattrResponse_descriptor_; +} + +const listxattrResponse& listxattrResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +listxattrResponse* listxattrResponse::default_instance_ = NULL; + +listxattrResponse* listxattrResponse::New() const { + return new listxattrResponse; +} + +void listxattrResponse::Clear() { + xattrs_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool listxattrResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .xtreemfs.pbrpc.XAttr xattrs = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_xattrs: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_xattrs())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_xattrs; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void listxattrResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .xtreemfs.pbrpc.XAttr xattrs = 1; + for (int i = 0; i < this->xattrs_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->xattrs(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* listxattrResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .xtreemfs.pbrpc.XAttr xattrs = 1; + for (int i = 0; i < this->xattrs_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->xattrs(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int listxattrResponse::ByteSize() const { + int total_size = 0; + + // repeated .xtreemfs.pbrpc.XAttr xattrs = 1; + total_size += 1 * this->xattrs_size(); + for (int i = 0; i < this->xattrs_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->xattrs(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void listxattrResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const listxattrResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void listxattrResponse::MergeFrom(const listxattrResponse& from) { + GOOGLE_CHECK_NE(&from, this); + xattrs_.MergeFrom(from.xattrs_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void listxattrResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void listxattrResponse::CopyFrom(const listxattrResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool listxattrResponse::IsInitialized() const { + + for (int i = 0; i < xattrs_size(); i++) { + if (!this->xattrs(i).IsInitialized()) return false; + } + return true; +} + +void listxattrResponse::Swap(listxattrResponse* other) { + if (other != this) { + xattrs_.Swap(&other->xattrs_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata listxattrResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = listxattrResponse_descriptor_; + metadata.reflection = listxattrResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int mkdirRequest::kVolumeNameFieldNumber; +const int mkdirRequest::kPathFieldNumber; +const int mkdirRequest::kModeFieldNumber; +#endif // !_MSC_VER + +mkdirRequest::mkdirRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void mkdirRequest::InitAsDefaultInstance() { +} + +mkdirRequest::mkdirRequest(const mkdirRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void mkdirRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + mode_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +mkdirRequest::~mkdirRequest() { + SharedDtor(); +} + +void mkdirRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void mkdirRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* mkdirRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return mkdirRequest_descriptor_; +} + +const mkdirRequest& mkdirRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +mkdirRequest* mkdirRequest::default_instance_ = NULL; + +mkdirRequest* mkdirRequest::New() const { + return new mkdirRequest; +} + +void mkdirRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + mode_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool mkdirRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_mode; + break; + } + + // required fixed32 mode = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_mode: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &mode_))); + set_has_mode(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void mkdirRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required fixed32 mode = 3; + if (has_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->mode(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* mkdirRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required fixed32 mode = 3; + if (has_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->mode(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int mkdirRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required fixed32 mode = 3; + if (has_mode()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void mkdirRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const mkdirRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void mkdirRequest::MergeFrom(const mkdirRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_mode()) { + set_mode(from.mode()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void mkdirRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void mkdirRequest::CopyFrom(const mkdirRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool mkdirRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void mkdirRequest::Swap(mkdirRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(mode_, other->mode_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata mkdirRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = mkdirRequest_descriptor_; + metadata.reflection = mkdirRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int openRequest::kVolumeNameFieldNumber; +const int openRequest::kPathFieldNumber; +const int openRequest::kFlagsFieldNumber; +const int openRequest::kModeFieldNumber; +const int openRequest::kAttributesFieldNumber; +const int openRequest::kCoordinatesFieldNumber; +#endif // !_MSC_VER + +openRequest::openRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void openRequest::InitAsDefaultInstance() { + coordinates_ = const_cast< ::xtreemfs::pbrpc::VivaldiCoordinates*>(&::xtreemfs::pbrpc::VivaldiCoordinates::default_instance()); +} + +openRequest::openRequest(const openRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void openRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + flags_ = 0u; + mode_ = 0u; + attributes_ = 0u; + coordinates_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +openRequest::~openRequest() { + SharedDtor(); +} + +void openRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + delete coordinates_; + } +} + +void openRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* openRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return openRequest_descriptor_; +} + +const openRequest& openRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +openRequest* openRequest::default_instance_ = NULL; + +openRequest* openRequest::New() const { + return new openRequest; +} + +void openRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + flags_ = 0u; + mode_ = 0u; + attributes_ = 0u; + if (has_coordinates()) { + if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool openRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_flags; + break; + } + + // required fixed32 flags = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_flags: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &flags_))); + set_has_flags(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_mode; + break; + } + + // required fixed32 mode = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_mode: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &mode_))); + set_has_mode(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_attributes; + break; + } + + // required fixed32 attributes = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_attributes: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &attributes_))); + set_has_attributes(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_coordinates; + break; + } + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_coordinates: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_coordinates())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void openRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required fixed32 flags = 3; + if (has_flags()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->flags(), output); + } + + // required fixed32 mode = 4; + if (has_mode()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->mode(), output); + } + + // required fixed32 attributes = 5; + if (has_attributes()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->attributes(), output); + } + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6; + if (has_coordinates()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->coordinates(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* openRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required fixed32 flags = 3; + if (has_flags()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->flags(), target); + } + + // required fixed32 mode = 4; + if (has_mode()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->mode(), target); + } + + // required fixed32 attributes = 5; + if (has_attributes()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->attributes(), target); + } + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6; + if (has_coordinates()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->coordinates(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int openRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required fixed32 flags = 3; + if (has_flags()) { + total_size += 1 + 4; + } + + // required fixed32 mode = 4; + if (has_mode()) { + total_size += 1 + 4; + } + + // required fixed32 attributes = 5; + if (has_attributes()) { + total_size += 1 + 4; + } + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6; + if (has_coordinates()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->coordinates()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void openRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const openRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void openRequest::MergeFrom(const openRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_flags()) { + set_flags(from.flags()); + } + if (from.has_mode()) { + set_mode(from.mode()); + } + if (from.has_attributes()) { + set_attributes(from.attributes()); + } + if (from.has_coordinates()) { + mutable_coordinates()->::xtreemfs::pbrpc::VivaldiCoordinates::MergeFrom(from.coordinates()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void openRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void openRequest::CopyFrom(const openRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool openRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false; + + if (has_coordinates()) { + if (!this->coordinates().IsInitialized()) return false; + } + return true; +} + +void openRequest::Swap(openRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(flags_, other->flags_); + std::swap(mode_, other->mode_); + std::swap(attributes_, other->attributes_); + std::swap(coordinates_, other->coordinates_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata openRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = openRequest_descriptor_; + metadata.reflection = openRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int openResponse::kCredsFieldNumber; +const int openResponse::kTimestampSFieldNumber; +#endif // !_MSC_VER + +openResponse::openResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void openResponse::InitAsDefaultInstance() { + creds_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +openResponse::openResponse(const openResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void openResponse::SharedCtor() { + _cached_size_ = 0; + creds_ = NULL; + timestamp_s_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +openResponse::~openResponse() { + SharedDtor(); +} + +void openResponse::SharedDtor() { + if (this != default_instance_) { + delete creds_; + } +} + +void openResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* openResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return openResponse_descriptor_; +} + +const openResponse& openResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +openResponse* openResponse::default_instance_ = NULL; + +openResponse* openResponse::New() const { + return new openResponse; +} + +void openResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_creds()) { + if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + timestamp_s_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool openResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials creds = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_creds())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_timestamp_s; + break; + } + + // required fixed32 timestamp_s = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_timestamp_s: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, ×tamp_s_))); + set_has_timestamp_s(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void openResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials creds = 1; + if (has_creds()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->creds(), output); + } + + // required fixed32 timestamp_s = 2; + if (has_timestamp_s()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->timestamp_s(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* openResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials creds = 1; + if (has_creds()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->creds(), target); + } + + // required fixed32 timestamp_s = 2; + if (has_timestamp_s()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->timestamp_s(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int openResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials creds = 1; + if (has_creds()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->creds()); + } + + // required fixed32 timestamp_s = 2; + if (has_timestamp_s()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void openResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const openResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void openResponse::MergeFrom(const openResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_creds()) { + mutable_creds()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.creds()); + } + if (from.has_timestamp_s()) { + set_timestamp_s(from.timestamp_s()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void openResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void openResponse::CopyFrom(const openResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool openResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_creds()) { + if (!this->creds().IsInitialized()) return false; + } + return true; +} + +void openResponse::Swap(openResponse* other) { + if (other != this) { + std::swap(creds_, other->creds_); + std::swap(timestamp_s_, other->timestamp_s_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata openResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = openResponse_descriptor_; + metadata.reflection = openResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int readdirRequest::kVolumeNameFieldNumber; +const int readdirRequest::kPathFieldNumber; +const int readdirRequest::kKnownEtagFieldNumber; +const int readdirRequest::kLimitDirectoryEntriesCountFieldNumber; +const int readdirRequest::kNamesOnlyFieldNumber; +const int readdirRequest::kSeenDirectoryEntriesCountFieldNumber; +#endif // !_MSC_VER + +readdirRequest::readdirRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void readdirRequest::InitAsDefaultInstance() { +} + +readdirRequest::readdirRequest(const readdirRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void readdirRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + known_etag_ = GOOGLE_ULONGLONG(0); + limit_directory_entries_count_ = 0u; + names_only_ = false; + seen_directory_entries_count_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +readdirRequest::~readdirRequest() { + SharedDtor(); +} + +void readdirRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void readdirRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* readdirRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return readdirRequest_descriptor_; +} + +const readdirRequest& readdirRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +readdirRequest* readdirRequest::default_instance_ = NULL; + +readdirRequest* readdirRequest::New() const { + return new readdirRequest; +} + +void readdirRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + known_etag_ = GOOGLE_ULONGLONG(0); + limit_directory_entries_count_ = 0u; + names_only_ = false; + seen_directory_entries_count_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool readdirRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_known_etag; + break; + } + + // required fixed64 known_etag = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_known_etag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &known_etag_))); + set_has_known_etag(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_limit_directory_entries_count; + break; + } + + // required fixed32 limit_directory_entries_count = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_limit_directory_entries_count: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &limit_directory_entries_count_))); + set_has_limit_directory_entries_count(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(40)) goto parse_names_only; + break; + } + + // required bool names_only = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_names_only: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &names_only_))); + set_has_names_only(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(49)) goto parse_seen_directory_entries_count; + break; + } + + // required fixed64 seen_directory_entries_count = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_seen_directory_entries_count: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &seen_directory_entries_count_))); + set_has_seen_directory_entries_count(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void readdirRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required fixed64 known_etag = 3; + if (has_known_etag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->known_etag(), output); + } + + // required fixed32 limit_directory_entries_count = 4; + if (has_limit_directory_entries_count()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->limit_directory_entries_count(), output); + } + + // required bool names_only = 5; + if (has_names_only()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->names_only(), output); + } + + // required fixed64 seen_directory_entries_count = 6; + if (has_seen_directory_entries_count()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(6, this->seen_directory_entries_count(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* readdirRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required fixed64 known_etag = 3; + if (has_known_etag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->known_etag(), target); + } + + // required fixed32 limit_directory_entries_count = 4; + if (has_limit_directory_entries_count()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->limit_directory_entries_count(), target); + } + + // required bool names_only = 5; + if (has_names_only()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->names_only(), target); + } + + // required fixed64 seen_directory_entries_count = 6; + if (has_seen_directory_entries_count()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(6, this->seen_directory_entries_count(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int readdirRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required fixed64 known_etag = 3; + if (has_known_etag()) { + total_size += 1 + 8; + } + + // required fixed32 limit_directory_entries_count = 4; + if (has_limit_directory_entries_count()) { + total_size += 1 + 4; + } + + // required bool names_only = 5; + if (has_names_only()) { + total_size += 1 + 1; + } + + // required fixed64 seen_directory_entries_count = 6; + if (has_seen_directory_entries_count()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void readdirRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const readdirRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void readdirRequest::MergeFrom(const readdirRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_known_etag()) { + set_known_etag(from.known_etag()); + } + if (from.has_limit_directory_entries_count()) { + set_limit_directory_entries_count(from.limit_directory_entries_count()); + } + if (from.has_names_only()) { + set_names_only(from.names_only()); + } + if (from.has_seen_directory_entries_count()) { + set_seen_directory_entries_count(from.seen_directory_entries_count()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void readdirRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void readdirRequest::CopyFrom(const readdirRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool readdirRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false; + + return true; +} + +void readdirRequest::Swap(readdirRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(known_etag_, other->known_etag_); + std::swap(limit_directory_entries_count_, other->limit_directory_entries_count_); + std::swap(names_only_, other->names_only_); + std::swap(seen_directory_entries_count_, other->seen_directory_entries_count_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata readdirRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = readdirRequest_descriptor_; + metadata.reflection = readdirRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int readlinkRequest::kVolumeNameFieldNumber; +const int readlinkRequest::kPathFieldNumber; +#endif // !_MSC_VER + +readlinkRequest::readlinkRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void readlinkRequest::InitAsDefaultInstance() { +} + +readlinkRequest::readlinkRequest(const readlinkRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void readlinkRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +readlinkRequest::~readlinkRequest() { + SharedDtor(); +} + +void readlinkRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void readlinkRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* readlinkRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return readlinkRequest_descriptor_; +} + +const readlinkRequest& readlinkRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +readlinkRequest* readlinkRequest::default_instance_ = NULL; + +readlinkRequest* readlinkRequest::New() const { + return new readlinkRequest; +} + +void readlinkRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool readlinkRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void readlinkRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* readlinkRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int readlinkRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void readlinkRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const readlinkRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void readlinkRequest::MergeFrom(const readlinkRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void readlinkRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void readlinkRequest::CopyFrom(const readlinkRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool readlinkRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void readlinkRequest::Swap(readlinkRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata readlinkRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = readlinkRequest_descriptor_; + metadata.reflection = readlinkRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int readlinkResponse::kLinkTargetPathFieldNumber; +#endif // !_MSC_VER + +readlinkResponse::readlinkResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void readlinkResponse::InitAsDefaultInstance() { +} + +readlinkResponse::readlinkResponse(const readlinkResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void readlinkResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +readlinkResponse::~readlinkResponse() { + SharedDtor(); +} + +void readlinkResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void readlinkResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* readlinkResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return readlinkResponse_descriptor_; +} + +const readlinkResponse& readlinkResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +readlinkResponse* readlinkResponse::default_instance_ = NULL; + +readlinkResponse* readlinkResponse::New() const { + return new readlinkResponse; +} + +void readlinkResponse::Clear() { + link_target_path_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool readlinkResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string link_target_path = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_link_target_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_link_target_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_target_path(this->link_target_path_size() - 1).data(), + this->link_target_path(this->link_target_path_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_link_target_path; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void readlinkResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated string link_target_path = 1; + for (int i = 0; i < this->link_target_path_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_target_path(i).data(), this->link_target_path(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->link_target_path(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* readlinkResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated string link_target_path = 1; + for (int i = 0; i < this->link_target_path_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_target_path(i).data(), this->link_target_path(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1, this->link_target_path(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int readlinkResponse::ByteSize() const { + int total_size = 0; + + // repeated string link_target_path = 1; + total_size += 1 * this->link_target_path_size(); + for (int i = 0; i < this->link_target_path_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->link_target_path(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void readlinkResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const readlinkResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void readlinkResponse::MergeFrom(const readlinkResponse& from) { + GOOGLE_CHECK_NE(&from, this); + link_target_path_.MergeFrom(from.link_target_path_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void readlinkResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void readlinkResponse::CopyFrom(const readlinkResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool readlinkResponse::IsInitialized() const { + + return true; +} + +void readlinkResponse::Swap(readlinkResponse* other) { + if (other != this) { + link_target_path_.Swap(&other->link_target_path_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata readlinkResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = readlinkResponse_descriptor_; + metadata.reflection = readlinkResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int removexattrRequest::kVolumeNameFieldNumber; +const int removexattrRequest::kPathFieldNumber; +const int removexattrRequest::kNameFieldNumber; +#endif // !_MSC_VER + +removexattrRequest::removexattrRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void removexattrRequest::InitAsDefaultInstance() { +} + +removexattrRequest::removexattrRequest(const removexattrRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void removexattrRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +removexattrRequest::~removexattrRequest() { + SharedDtor(); +} + +void removexattrRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void removexattrRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* removexattrRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return removexattrRequest_descriptor_; +} + +const removexattrRequest& removexattrRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +removexattrRequest* removexattrRequest::default_instance_ = NULL; + +removexattrRequest* removexattrRequest::New() const { + return new removexattrRequest; +} + +void removexattrRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool removexattrRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_name; + break; + } + + // required string name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void removexattrRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required string name = 3; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* removexattrRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required string name = 3; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int removexattrRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void removexattrRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const removexattrRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void removexattrRequest::MergeFrom(const removexattrRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_name()) { + set_name(from.name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void removexattrRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void removexattrRequest::CopyFrom(const removexattrRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool removexattrRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void removexattrRequest::Swap(removexattrRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(name_, other->name_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata removexattrRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = removexattrRequest_descriptor_; + metadata.reflection = removexattrRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int renameRequest::kVolumeNameFieldNumber; +const int renameRequest::kSourcePathFieldNumber; +const int renameRequest::kTargetPathFieldNumber; +#endif // !_MSC_VER + +renameRequest::renameRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void renameRequest::InitAsDefaultInstance() { +} + +renameRequest::renameRequest(const renameRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void renameRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + source_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +renameRequest::~renameRequest() { + SharedDtor(); +} + +void renameRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (source_path_ != &::google::protobuf::internal::kEmptyString) { + delete source_path_; + } + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + delete target_path_; + } + if (this != default_instance_) { + } +} + +void renameRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* renameRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return renameRequest_descriptor_; +} + +const renameRequest& renameRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +renameRequest* renameRequest::default_instance_ = NULL; + +renameRequest* renameRequest::New() const { + return new renameRequest; +} + +void renameRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_source_path()) { + if (source_path_ != &::google::protobuf::internal::kEmptyString) { + source_path_->clear(); + } + } + if (has_target_path()) { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + target_path_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool renameRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_source_path; + break; + } + + // required string source_path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_source_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_source_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->source_path().data(), this->source_path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_target_path; + break; + } + + // required string target_path = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_target_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_target_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void renameRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string source_path = 2; + if (has_source_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->source_path().data(), this->source_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->source_path(), output); + } + + // required string target_path = 3; + if (has_target_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->target_path(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* renameRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string source_path = 2; + if (has_source_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->source_path().data(), this->source_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->source_path(), target); + } + + // required string target_path = 3; + if (has_target_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->target_path(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int renameRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string source_path = 2; + if (has_source_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->source_path()); + } + + // required string target_path = 3; + if (has_target_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->target_path()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void renameRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const renameRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void renameRequest::MergeFrom(const renameRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_source_path()) { + set_source_path(from.source_path()); + } + if (from.has_target_path()) { + set_target_path(from.target_path()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void renameRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void renameRequest::CopyFrom(const renameRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool renameRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void renameRequest::Swap(renameRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(source_path_, other->source_path_); + std::swap(target_path_, other->target_path_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata renameRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = renameRequest_descriptor_; + metadata.reflection = renameRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int renameResponse::kTimestampSFieldNumber; +const int renameResponse::kCredsFieldNumber; +#endif // !_MSC_VER + +renameResponse::renameResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void renameResponse::InitAsDefaultInstance() { + creds_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +renameResponse::renameResponse(const renameResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void renameResponse::SharedCtor() { + _cached_size_ = 0; + timestamp_s_ = 0u; + creds_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +renameResponse::~renameResponse() { + SharedDtor(); +} + +void renameResponse::SharedDtor() { + if (this != default_instance_) { + delete creds_; + } +} + +void renameResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* renameResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return renameResponse_descriptor_; +} + +const renameResponse& renameResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +renameResponse* renameResponse::default_instance_ = NULL; + +renameResponse* renameResponse::New() const { + return new renameResponse; +} + +void renameResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + timestamp_s_ = 0u; + if (has_creds()) { + if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool renameResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 timestamp_s = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, ×tamp_s_))); + set_has_timestamp_s(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_creds; + break; + } + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_creds: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_creds())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void renameResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->timestamp_s(), output); + } + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + if (has_creds()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->creds(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* renameResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->timestamp_s(), target); + } + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + if (has_creds()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->creds(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int renameResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + total_size += 1 + 4; + } + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + if (has_creds()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->creds()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void renameResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const renameResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void renameResponse::MergeFrom(const renameResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_timestamp_s()) { + set_timestamp_s(from.timestamp_s()); + } + if (from.has_creds()) { + mutable_creds()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.creds()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void renameResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void renameResponse::CopyFrom(const renameResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool renameResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_creds()) { + if (!this->creds().IsInitialized()) return false; + } + return true; +} + +void renameResponse::Swap(renameResponse* other) { + if (other != this) { + std::swap(timestamp_s_, other->timestamp_s_); + std::swap(creds_, other->creds_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata renameResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = renameResponse_descriptor_; + metadata.reflection = renameResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int rmdirRequest::kVolumeNameFieldNumber; +const int rmdirRequest::kPathFieldNumber; +#endif // !_MSC_VER + +rmdirRequest::rmdirRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void rmdirRequest::InitAsDefaultInstance() { +} + +rmdirRequest::rmdirRequest(const rmdirRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void rmdirRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +rmdirRequest::~rmdirRequest() { + SharedDtor(); +} + +void rmdirRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void rmdirRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* rmdirRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return rmdirRequest_descriptor_; +} + +const rmdirRequest& rmdirRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +rmdirRequest* rmdirRequest::default_instance_ = NULL; + +rmdirRequest* rmdirRequest::New() const { + return new rmdirRequest; +} + +void rmdirRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool rmdirRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void rmdirRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* rmdirRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int rmdirRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void rmdirRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const rmdirRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void rmdirRequest::MergeFrom(const rmdirRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void rmdirRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void rmdirRequest::CopyFrom(const rmdirRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool rmdirRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void rmdirRequest::Swap(rmdirRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata rmdirRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = rmdirRequest_descriptor_; + metadata.reflection = rmdirRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int setattrRequest::kVolumeNameFieldNumber; +const int setattrRequest::kPathFieldNumber; +const int setattrRequest::kStbufFieldNumber; +const int setattrRequest::kToSetFieldNumber; +#endif // !_MSC_VER + +setattrRequest::setattrRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void setattrRequest::InitAsDefaultInstance() { + stbuf_ = const_cast< ::xtreemfs::pbrpc::Stat*>(&::xtreemfs::pbrpc::Stat::default_instance()); +} + +setattrRequest::setattrRequest(const setattrRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void setattrRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + stbuf_ = NULL; + to_set_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +setattrRequest::~setattrRequest() { + SharedDtor(); +} + +void setattrRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + delete stbuf_; + } +} + +void setattrRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* setattrRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return setattrRequest_descriptor_; +} + +const setattrRequest& setattrRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +setattrRequest* setattrRequest::default_instance_ = NULL; + +setattrRequest* setattrRequest::New() const { + return new setattrRequest; +} + +void setattrRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_stbuf()) { + if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear(); + } + to_set_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool setattrRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_stbuf; + break; + } + + // required .xtreemfs.pbrpc.Stat stbuf = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_stbuf: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_stbuf())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_to_set; + break; + } + + // required fixed32 to_set = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_to_set: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &to_set_))); + set_has_to_set(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void setattrRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required .xtreemfs.pbrpc.Stat stbuf = 3; + if (has_stbuf()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->stbuf(), output); + } + + // required fixed32 to_set = 4; + if (has_to_set()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->to_set(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* setattrRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required .xtreemfs.pbrpc.Stat stbuf = 3; + if (has_stbuf()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->stbuf(), target); + } + + // required fixed32 to_set = 4; + if (has_to_set()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->to_set(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int setattrRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required .xtreemfs.pbrpc.Stat stbuf = 3; + if (has_stbuf()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->stbuf()); + } + + // required fixed32 to_set = 4; + if (has_to_set()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void setattrRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const setattrRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void setattrRequest::MergeFrom(const setattrRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_stbuf()) { + mutable_stbuf()->::xtreemfs::pbrpc::Stat::MergeFrom(from.stbuf()); + } + if (from.has_to_set()) { + set_to_set(from.to_set()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void setattrRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void setattrRequest::CopyFrom(const setattrRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool setattrRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + if (has_stbuf()) { + if (!this->stbuf().IsInitialized()) return false; + } + return true; +} + +void setattrRequest::Swap(setattrRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(stbuf_, other->stbuf_); + std::swap(to_set_, other->to_set_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata setattrRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = setattrRequest_descriptor_; + metadata.reflection = setattrRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int setxattrRequest::kVolumeNameFieldNumber; +const int setxattrRequest::kPathFieldNumber; +const int setxattrRequest::kNameFieldNumber; +const int setxattrRequest::kValueFieldNumber; +const int setxattrRequest::kValueBytesStringFieldNumber; +const int setxattrRequest::kFlagsFieldNumber; +#endif // !_MSC_VER + +setxattrRequest::setxattrRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void setxattrRequest::InitAsDefaultInstance() { +} + +setxattrRequest::setxattrRequest(const setxattrRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void setxattrRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + flags_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +setxattrRequest::~setxattrRequest() { + SharedDtor(); +} + +void setxattrRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + delete value_bytes_string_; + } + if (this != default_instance_) { + } +} + +void setxattrRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* setxattrRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return setxattrRequest_descriptor_; +} + +const setxattrRequest& setxattrRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +setxattrRequest* setxattrRequest::default_instance_ = NULL; + +setxattrRequest* setxattrRequest::New() const { + return new setxattrRequest; +} + +void setxattrRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + if (has_value()) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + } + if (has_value_bytes_string()) { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + value_bytes_string_->clear(); + } + } + flags_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool setxattrRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_name; + break; + } + + // required string name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_value; + break; + } + + // required string value = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_value: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_value())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_flags; + break; + } + + // required fixed32 flags = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_flags: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &flags_))); + set_has_flags(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_value_bytes_string; + break; + } + + // optional bytes value_bytes_string = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_value_bytes_string: + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_value_bytes_string())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void setxattrRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required string name = 3; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->name(), output); + } + + // required string value = 4; + if (has_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->value(), output); + } + + // required fixed32 flags = 5; + if (has_flags()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->flags(), output); + } + + // optional bytes value_bytes_string = 6; + if (has_value_bytes_string()) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 6, this->value_bytes_string(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* setxattrRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required string name = 3; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->name(), target); + } + + // required string value = 4; + if (has_value()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->value().data(), this->value().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->value(), target); + } + + // required fixed32 flags = 5; + if (has_flags()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->flags(), target); + } + + // optional bytes value_bytes_string = 6; + if (has_value_bytes_string()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 6, this->value_bytes_string(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int setxattrRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // required string value = 4; + if (has_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->value()); + } + + // optional bytes value_bytes_string = 6; + if (has_value_bytes_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->value_bytes_string()); + } + + // required fixed32 flags = 5; + if (has_flags()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void setxattrRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const setxattrRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void setxattrRequest::MergeFrom(const setxattrRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_value()) { + set_value(from.value()); + } + if (from.has_value_bytes_string()) { + set_value_bytes_string(from.value_bytes_string()); + } + if (from.has_flags()) { + set_flags(from.flags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void setxattrRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void setxattrRequest::CopyFrom(const setxattrRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool setxattrRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000002f) != 0x0000002f) return false; + + return true; +} + +void setxattrRequest::Swap(setxattrRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(name_, other->name_); + std::swap(value_, other->value_); + std::swap(value_bytes_string_, other->value_bytes_string_); + std::swap(flags_, other->flags_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata setxattrRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = setxattrRequest_descriptor_; + metadata.reflection = setxattrRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int statvfsRequest::kVolumeNameFieldNumber; +const int statvfsRequest::kKnownEtagFieldNumber; +#endif // !_MSC_VER + +statvfsRequest::statvfsRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void statvfsRequest::InitAsDefaultInstance() { +} + +statvfsRequest::statvfsRequest(const statvfsRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void statvfsRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + known_etag_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +statvfsRequest::~statvfsRequest() { + SharedDtor(); +} + +void statvfsRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (this != default_instance_) { + } +} + +void statvfsRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* statvfsRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return statvfsRequest_descriptor_; +} + +const statvfsRequest& statvfsRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +statvfsRequest* statvfsRequest::default_instance_ = NULL; + +statvfsRequest* statvfsRequest::New() const { + return new statvfsRequest; +} + +void statvfsRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + known_etag_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool statvfsRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(41)) goto parse_known_etag; + break; + } + + // required fixed64 known_etag = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_known_etag: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &known_etag_))); + set_has_known_etag(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void statvfsRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required fixed64 known_etag = 5; + if (has_known_etag()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(5, this->known_etag(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* statvfsRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required fixed64 known_etag = 5; + if (has_known_etag()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(5, this->known_etag(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int statvfsRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required fixed64 known_etag = 5; + if (has_known_etag()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void statvfsRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const statvfsRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void statvfsRequest::MergeFrom(const statvfsRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_known_etag()) { + set_known_etag(from.known_etag()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void statvfsRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void statvfsRequest::CopyFrom(const statvfsRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool statvfsRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void statvfsRequest::Swap(statvfsRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(known_etag_, other->known_etag_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata statvfsRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = statvfsRequest_descriptor_; + metadata.reflection = statvfsRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int symlinkRequest::kVolumeNameFieldNumber; +const int symlinkRequest::kTargetPathFieldNumber; +const int symlinkRequest::kLinkPathFieldNumber; +#endif // !_MSC_VER + +symlinkRequest::symlinkRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void symlinkRequest::InitAsDefaultInstance() { +} + +symlinkRequest::symlinkRequest(const symlinkRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void symlinkRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + link_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +symlinkRequest::~symlinkRequest() { + SharedDtor(); +} + +void symlinkRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + delete target_path_; + } + if (link_path_ != &::google::protobuf::internal::kEmptyString) { + delete link_path_; + } + if (this != default_instance_) { + } +} + +void symlinkRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* symlinkRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return symlinkRequest_descriptor_; +} + +const symlinkRequest& symlinkRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +symlinkRequest* symlinkRequest::default_instance_ = NULL; + +symlinkRequest* symlinkRequest::New() const { + return new symlinkRequest; +} + +void symlinkRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_target_path()) { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + target_path_->clear(); + } + } + if (has_link_path()) { + if (link_path_ != &::google::protobuf::internal::kEmptyString) { + link_path_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool symlinkRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_target_path; + break; + } + + // required string target_path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_target_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_target_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_link_path; + break; + } + + // required string link_path = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_link_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_link_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_path().data(), this->link_path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void symlinkRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string target_path = 2; + if (has_target_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->target_path(), output); + } + + // required string link_path = 3; + if (has_link_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_path().data(), this->link_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->link_path(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* symlinkRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string target_path = 2; + if (has_target_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->target_path().data(), this->target_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->target_path(), target); + } + + // required string link_path = 3; + if (has_link_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->link_path().data(), this->link_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->link_path(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int symlinkRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string target_path = 2; + if (has_target_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->target_path()); + } + + // required string link_path = 3; + if (has_link_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->link_path()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void symlinkRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const symlinkRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void symlinkRequest::MergeFrom(const symlinkRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_target_path()) { + set_target_path(from.target_path()); + } + if (from.has_link_path()) { + set_link_path(from.link_path()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void symlinkRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void symlinkRequest::CopyFrom(const symlinkRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool symlinkRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void symlinkRequest::Swap(symlinkRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(target_path_, other->target_path_); + std::swap(link_path_, other->link_path_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata symlinkRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = symlinkRequest_descriptor_; + metadata.reflection = symlinkRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int unlinkRequest::kVolumeNameFieldNumber; +const int unlinkRequest::kPathFieldNumber; +#endif // !_MSC_VER + +unlinkRequest::unlinkRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void unlinkRequest::InitAsDefaultInstance() { +} + +unlinkRequest::unlinkRequest(const unlinkRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void unlinkRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +unlinkRequest::~unlinkRequest() { + SharedDtor(); +} + +void unlinkRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void unlinkRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* unlinkRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return unlinkRequest_descriptor_; +} + +const unlinkRequest& unlinkRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +unlinkRequest* unlinkRequest::default_instance_ = NULL; + +unlinkRequest* unlinkRequest::New() const { + return new unlinkRequest; +} + +void unlinkRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool unlinkRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void unlinkRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* unlinkRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int unlinkRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void unlinkRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const unlinkRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void unlinkRequest::MergeFrom(const unlinkRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void unlinkRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void unlinkRequest::CopyFrom(const unlinkRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool unlinkRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void unlinkRequest::Swap(unlinkRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata unlinkRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = unlinkRequest_descriptor_; + metadata.reflection = unlinkRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int unlinkResponse::kTimestampSFieldNumber; +const int unlinkResponse::kCredsFieldNumber; +#endif // !_MSC_VER + +unlinkResponse::unlinkResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void unlinkResponse::InitAsDefaultInstance() { + creds_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +unlinkResponse::unlinkResponse(const unlinkResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void unlinkResponse::SharedCtor() { + _cached_size_ = 0; + timestamp_s_ = 0u; + creds_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +unlinkResponse::~unlinkResponse() { + SharedDtor(); +} + +void unlinkResponse::SharedDtor() { + if (this != default_instance_) { + delete creds_; + } +} + +void unlinkResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* unlinkResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return unlinkResponse_descriptor_; +} + +const unlinkResponse& unlinkResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +unlinkResponse* unlinkResponse::default_instance_ = NULL; + +unlinkResponse* unlinkResponse::New() const { + return new unlinkResponse; +} + +void unlinkResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + timestamp_s_ = 0u; + if (has_creds()) { + if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool unlinkResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 timestamp_s = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, ×tamp_s_))); + set_has_timestamp_s(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_creds; + break; + } + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_creds: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_creds())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void unlinkResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->timestamp_s(), output); + } + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + if (has_creds()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->creds(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* unlinkResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->timestamp_s(), target); + } + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + if (has_creds()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->creds(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int unlinkResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + total_size += 1 + 4; + } + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + if (has_creds()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->creds()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void unlinkResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const unlinkResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void unlinkResponse::MergeFrom(const unlinkResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_timestamp_s()) { + set_timestamp_s(from.timestamp_s()); + } + if (from.has_creds()) { + mutable_creds()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.creds()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void unlinkResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void unlinkResponse::CopyFrom(const unlinkResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool unlinkResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_creds()) { + if (!this->creds().IsInitialized()) return false; + } + return true; +} + +void unlinkResponse::Swap(unlinkResponse* other) { + if (other != this) { + std::swap(timestamp_s_, other->timestamp_s_); + std::swap(creds_, other->creds_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata unlinkResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = unlinkResponse_descriptor_; + metadata.reflection = unlinkResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int accessRequest::kVolumeNameFieldNumber; +const int accessRequest::kPathFieldNumber; +const int accessRequest::kFlagsFieldNumber; +#endif // !_MSC_VER + +accessRequest::accessRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void accessRequest::InitAsDefaultInstance() { +} + +accessRequest::accessRequest(const accessRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void accessRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + flags_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +accessRequest::~accessRequest() { + SharedDtor(); +} + +void accessRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void accessRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* accessRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return accessRequest_descriptor_; +} + +const accessRequest& accessRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +accessRequest* accessRequest::default_instance_ = NULL; + +accessRequest* accessRequest::New() const { + return new accessRequest; +} + +void accessRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + flags_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool accessRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // required string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_flags; + break; + } + + // required fixed32 flags = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_flags: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &flags_))); + set_has_flags(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void accessRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // required fixed32 flags = 3; + if (has_flags()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->flags(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* accessRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + // required string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // required fixed32 flags = 3; + if (has_flags()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->flags(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int accessRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // required fixed32 flags = 3; + if (has_flags()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void accessRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const accessRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void accessRequest::MergeFrom(const accessRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_flags()) { + set_flags(from.flags()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void accessRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void accessRequest::CopyFrom(const accessRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool accessRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void accessRequest::Swap(accessRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(path_, other->path_); + std::swap(flags_, other->flags_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata accessRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = accessRequest_descriptor_; + metadata.reflection = accessRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_check_file_existsRequest::kVolumeIdFieldNumber; +const int xtreemfs_check_file_existsRequest::kFileIdsFieldNumber; +const int xtreemfs_check_file_existsRequest::kOsdUuidFieldNumber; +#endif // !_MSC_VER + +xtreemfs_check_file_existsRequest::xtreemfs_check_file_existsRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_check_file_existsRequest::InitAsDefaultInstance() { +} + +xtreemfs_check_file_existsRequest::xtreemfs_check_file_existsRequest(const xtreemfs_check_file_existsRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_check_file_existsRequest::SharedCtor() { + _cached_size_ = 0; + volume_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_check_file_existsRequest::~xtreemfs_check_file_existsRequest() { + SharedDtor(); +} + +void xtreemfs_check_file_existsRequest::SharedDtor() { + if (volume_id_ != &::google::protobuf::internal::kEmptyString) { + delete volume_id_; + } + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete osd_uuid_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_check_file_existsRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_check_file_existsRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_check_file_existsRequest_descriptor_; +} + +const xtreemfs_check_file_existsRequest& xtreemfs_check_file_existsRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_check_file_existsRequest* xtreemfs_check_file_existsRequest::default_instance_ = NULL; + +xtreemfs_check_file_existsRequest* xtreemfs_check_file_existsRequest::New() const { + return new xtreemfs_check_file_existsRequest; +} + +void xtreemfs_check_file_existsRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_id()) { + if (volume_id_ != &::google::protobuf::internal::kEmptyString) { + volume_id_->clear(); + } + } + if (has_osd_uuid()) { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + osd_uuid_->clear(); + } + } + } + file_ids_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_check_file_existsRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_id().data(), this->volume_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_ids; + break; + } + + // repeated string file_ids = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_ids: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_file_ids())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_ids(this->file_ids_size() - 1).data(), + this->file_ids(this->file_ids_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_ids; + if (input->ExpectTag(26)) goto parse_osd_uuid; + break; + } + + // required string osd_uuid = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_osd_uuid: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_osd_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_check_file_existsRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_id = 1; + if (has_volume_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_id().data(), this->volume_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_id(), output); + } + + // repeated string file_ids = 2; + for (int i = 0; i < this->file_ids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_ids(i).data(), this->file_ids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_ids(i), output); + } + + // required string osd_uuid = 3; + if (has_osd_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->osd_uuid(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_check_file_existsRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_id = 1; + if (has_volume_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_id().data(), this->volume_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_id(), target); + } + + // repeated string file_ids = 2; + for (int i = 0; i < this->file_ids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_ids(i).data(), this->file_ids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(2, this->file_ids(i), target); + } + + // required string osd_uuid = 3; + if (has_osd_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->osd_uuid(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_check_file_existsRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_id = 1; + if (has_volume_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_id()); + } + + // required string osd_uuid = 3; + if (has_osd_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->osd_uuid()); + } + + } + // repeated string file_ids = 2; + total_size += 1 * this->file_ids_size(); + for (int i = 0; i < this->file_ids_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_ids(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_check_file_existsRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_check_file_existsRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_check_file_existsRequest::MergeFrom(const xtreemfs_check_file_existsRequest& from) { + GOOGLE_CHECK_NE(&from, this); + file_ids_.MergeFrom(from.file_ids_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_id()) { + set_volume_id(from.volume_id()); + } + if (from.has_osd_uuid()) { + set_osd_uuid(from.osd_uuid()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_check_file_existsRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_check_file_existsRequest::CopyFrom(const xtreemfs_check_file_existsRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_check_file_existsRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; + + return true; +} + +void xtreemfs_check_file_existsRequest::Swap(xtreemfs_check_file_existsRequest* other) { + if (other != this) { + std::swap(volume_id_, other->volume_id_); + file_ids_.Swap(&other->file_ids_); + std::swap(osd_uuid_, other->osd_uuid_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_check_file_existsRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_check_file_existsRequest_descriptor_; + metadata.reflection = xtreemfs_check_file_existsRequest_reflection_; + return metadata; +} + + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* xtreemfs_check_file_existsResponse_FILE_STATE_descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_check_file_existsResponse_FILE_STATE_descriptor_; +} +bool xtreemfs_check_file_existsResponse_FILE_STATE_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const xtreemfs_check_file_existsResponse_FILE_STATE xtreemfs_check_file_existsResponse::DELETED; +const xtreemfs_check_file_existsResponse_FILE_STATE xtreemfs_check_file_existsResponse::REGISTERED; +const xtreemfs_check_file_existsResponse_FILE_STATE xtreemfs_check_file_existsResponse::ABANDONED; +const xtreemfs_check_file_existsResponse_FILE_STATE xtreemfs_check_file_existsResponse::FILE_STATE_MIN; +const xtreemfs_check_file_existsResponse_FILE_STATE xtreemfs_check_file_existsResponse::FILE_STATE_MAX; +const int xtreemfs_check_file_existsResponse::FILE_STATE_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int xtreemfs_check_file_existsResponse::kVolumeExistsFieldNumber; +const int xtreemfs_check_file_existsResponse::kFileStatesFieldNumber; +#endif // !_MSC_VER + +xtreemfs_check_file_existsResponse::xtreemfs_check_file_existsResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_check_file_existsResponse::InitAsDefaultInstance() { +} + +xtreemfs_check_file_existsResponse::xtreemfs_check_file_existsResponse(const xtreemfs_check_file_existsResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_check_file_existsResponse::SharedCtor() { + _cached_size_ = 0; + volume_exists_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_check_file_existsResponse::~xtreemfs_check_file_existsResponse() { + SharedDtor(); +} + +void xtreemfs_check_file_existsResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_check_file_existsResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_check_file_existsResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_check_file_existsResponse_descriptor_; +} + +const xtreemfs_check_file_existsResponse& xtreemfs_check_file_existsResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_check_file_existsResponse* xtreemfs_check_file_existsResponse::default_instance_ = NULL; + +xtreemfs_check_file_existsResponse* xtreemfs_check_file_existsResponse::New() const { + return new xtreemfs_check_file_existsResponse; +} + +void xtreemfs_check_file_existsResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + volume_exists_ = false; + } + file_states_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_check_file_existsResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required bool volume_exists = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &volume_exists_))); + set_has_volume_exists(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_states; + break; + } + + // repeated .xtreemfs.pbrpc.xtreemfs_check_file_existsResponse.FILE_STATE file_states = 2 [packed = true]; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_states: + ::google::protobuf::uint32 length; + DO_(input->ReadVarint32(&length)); + ::google::protobuf::io::CodedInputStream::Limit limit = input->PushLimit(length); + while (input->BytesUntilLimit() > 0) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE_IsValid(value)) { + add_file_states(static_cast< ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE >(value)); + } + } + input->PopLimit(limit); + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE_IsValid(value)) { + add_file_states(static_cast< ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_check_file_existsResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required bool volume_exists = 1; + if (has_volume_exists()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->volume_exists(), output); + } + + // repeated .xtreemfs.pbrpc.xtreemfs_check_file_existsResponse.FILE_STATE file_states = 2 [packed = true]; + if (this->file_states_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag( + 2, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + output); + output->WriteVarint32(_file_states_cached_byte_size_); + } + for (int i = 0; i < this->file_states_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnumNoTag( + this->file_states(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_check_file_existsResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required bool volume_exists = 1; + if (has_volume_exists()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->volume_exists(), target); + } + + // repeated .xtreemfs.pbrpc.xtreemfs_check_file_existsResponse.FILE_STATE file_states = 2 [packed = true]; + if (this->file_states_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 2, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( _file_states_cached_byte_size_, target); + } + for (int i = 0; i < this->file_states_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumNoTagToArray( + this->file_states(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_check_file_existsResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required bool volume_exists = 1; + if (has_volume_exists()) { + total_size += 1 + 1; + } + + } + // repeated .xtreemfs.pbrpc.xtreemfs_check_file_existsResponse.FILE_STATE file_states = 2 [packed = true]; + { + int data_size = 0; + for (int i = 0; i < this->file_states_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->file_states(i)); + } + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size(data_size); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _file_states_cached_byte_size_ = data_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_check_file_existsResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_check_file_existsResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_check_file_existsResponse::MergeFrom(const xtreemfs_check_file_existsResponse& from) { + GOOGLE_CHECK_NE(&from, this); + file_states_.MergeFrom(from.file_states_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_exists()) { + set_volume_exists(from.volume_exists()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_check_file_existsResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_check_file_existsResponse::CopyFrom(const xtreemfs_check_file_existsResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_check_file_existsResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_check_file_existsResponse::Swap(xtreemfs_check_file_existsResponse* other) { + if (other != this) { + std::swap(volume_exists_, other->volume_exists_); + file_states_.Swap(&other->file_states_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_check_file_existsResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_check_file_existsResponse_descriptor_; + metadata.reflection = xtreemfs_check_file_existsResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_dump_restore_databaseRequest::kDumpFileFieldNumber; +#endif // !_MSC_VER + +xtreemfs_dump_restore_databaseRequest::xtreemfs_dump_restore_databaseRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_dump_restore_databaseRequest::InitAsDefaultInstance() { +} + +xtreemfs_dump_restore_databaseRequest::xtreemfs_dump_restore_databaseRequest(const xtreemfs_dump_restore_databaseRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_dump_restore_databaseRequest::SharedCtor() { + _cached_size_ = 0; + dump_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_dump_restore_databaseRequest::~xtreemfs_dump_restore_databaseRequest() { + SharedDtor(); +} + +void xtreemfs_dump_restore_databaseRequest::SharedDtor() { + if (dump_file_ != &::google::protobuf::internal::kEmptyString) { + delete dump_file_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_dump_restore_databaseRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_dump_restore_databaseRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_dump_restore_databaseRequest_descriptor_; +} + +const xtreemfs_dump_restore_databaseRequest& xtreemfs_dump_restore_databaseRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_dump_restore_databaseRequest* xtreemfs_dump_restore_databaseRequest::default_instance_ = NULL; + +xtreemfs_dump_restore_databaseRequest* xtreemfs_dump_restore_databaseRequest::New() const { + return new xtreemfs_dump_restore_databaseRequest; +} + +void xtreemfs_dump_restore_databaseRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_dump_file()) { + if (dump_file_ != &::google::protobuf::internal::kEmptyString) { + dump_file_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_dump_restore_databaseRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string dump_file = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_dump_file())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->dump_file().data(), this->dump_file().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_dump_restore_databaseRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string dump_file = 1; + if (has_dump_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->dump_file().data(), this->dump_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->dump_file(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_dump_restore_databaseRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string dump_file = 1; + if (has_dump_file()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->dump_file().data(), this->dump_file().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->dump_file(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_dump_restore_databaseRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string dump_file = 1; + if (has_dump_file()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->dump_file()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_dump_restore_databaseRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_dump_restore_databaseRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_dump_restore_databaseRequest::MergeFrom(const xtreemfs_dump_restore_databaseRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_dump_file()) { + set_dump_file(from.dump_file()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_dump_restore_databaseRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_dump_restore_databaseRequest::CopyFrom(const xtreemfs_dump_restore_databaseRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_dump_restore_databaseRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_dump_restore_databaseRequest::Swap(xtreemfs_dump_restore_databaseRequest* other) { + if (other != this) { + std::swap(dump_file_, other->dump_file_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_dump_restore_databaseRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_dump_restore_databaseRequest_descriptor_; + metadata.reflection = xtreemfs_dump_restore_databaseRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_get_suitable_osdsRequest::kFileIdFieldNumber; +const int xtreemfs_get_suitable_osdsRequest::kPathFieldNumber; +const int xtreemfs_get_suitable_osdsRequest::kVolumeNameFieldNumber; +const int xtreemfs_get_suitable_osdsRequest::kNumOsdsFieldNumber; +#endif // !_MSC_VER + +xtreemfs_get_suitable_osdsRequest::xtreemfs_get_suitable_osdsRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_get_suitable_osdsRequest::InitAsDefaultInstance() { +} + +xtreemfs_get_suitable_osdsRequest::xtreemfs_get_suitable_osdsRequest(const xtreemfs_get_suitable_osdsRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_get_suitable_osdsRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + num_osds_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_get_suitable_osdsRequest::~xtreemfs_get_suitable_osdsRequest() { + SharedDtor(); +} + +void xtreemfs_get_suitable_osdsRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_get_suitable_osdsRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_get_suitable_osdsRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_get_suitable_osdsRequest_descriptor_; +} + +const xtreemfs_get_suitable_osdsRequest& xtreemfs_get_suitable_osdsRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_get_suitable_osdsRequest* xtreemfs_get_suitable_osdsRequest::default_instance_ = NULL; + +xtreemfs_get_suitable_osdsRequest* xtreemfs_get_suitable_osdsRequest::New() const { + return new xtreemfs_get_suitable_osdsRequest; +} + +void xtreemfs_get_suitable_osdsRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + num_osds_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_get_suitable_osdsRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_num_osds; + break; + } + + // required fixed32 num_osds = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_num_osds: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &num_osds_))); + set_has_num_osds(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_path; + break; + } + + // optional string path = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_volume_name; + break; + } + + // optional string volume_name = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_volume_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + // required fixed32 num_osds = 2; + if (has_num_osds()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->num_osds(), output); + } + + // optional string path = 3; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->path(), output); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->volume_name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + // required fixed32 num_osds = 2; + if (has_num_osds()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->num_osds(), target); + } + + // optional string path = 3; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->path(), target); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->volume_name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_get_suitable_osdsRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // optional string path = 3; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required fixed32 num_osds = 2; + if (has_num_osds()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_get_suitable_osdsRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_get_suitable_osdsRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_get_suitable_osdsRequest::MergeFrom(const xtreemfs_get_suitable_osdsRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_num_osds()) { + set_num_osds(from.num_osds()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_get_suitable_osdsRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_get_suitable_osdsRequest::CopyFrom(const xtreemfs_get_suitable_osdsRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_get_suitable_osdsRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false; + + return true; +} + +void xtreemfs_get_suitable_osdsRequest::Swap(xtreemfs_get_suitable_osdsRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(path_, other->path_); + std::swap(volume_name_, other->volume_name_); + std::swap(num_osds_, other->num_osds_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_get_suitable_osdsRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_get_suitable_osdsRequest_descriptor_; + metadata.reflection = xtreemfs_get_suitable_osdsRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_get_suitable_osdsResponse::kOsdUuidsFieldNumber; +#endif // !_MSC_VER + +xtreemfs_get_suitable_osdsResponse::xtreemfs_get_suitable_osdsResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_get_suitable_osdsResponse::InitAsDefaultInstance() { +} + +xtreemfs_get_suitable_osdsResponse::xtreemfs_get_suitable_osdsResponse(const xtreemfs_get_suitable_osdsResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_get_suitable_osdsResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_get_suitable_osdsResponse::~xtreemfs_get_suitable_osdsResponse() { + SharedDtor(); +} + +void xtreemfs_get_suitable_osdsResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_get_suitable_osdsResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_get_suitable_osdsResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_get_suitable_osdsResponse_descriptor_; +} + +const xtreemfs_get_suitable_osdsResponse& xtreemfs_get_suitable_osdsResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_get_suitable_osdsResponse* xtreemfs_get_suitable_osdsResponse::default_instance_ = NULL; + +xtreemfs_get_suitable_osdsResponse* xtreemfs_get_suitable_osdsResponse::New() const { + return new xtreemfs_get_suitable_osdsResponse; +} + +void xtreemfs_get_suitable_osdsResponse::Clear() { + osd_uuids_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_get_suitable_osdsResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string osd_uuids = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_osd_uuids: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_osd_uuids())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(this->osd_uuids_size() - 1).data(), + this->osd_uuids(this->osd_uuids_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_osd_uuids; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_get_suitable_osdsResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated string osd_uuids = 1; + for (int i = 0; i < this->osd_uuids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(i).data(), this->osd_uuids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->osd_uuids(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_get_suitable_osdsResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated string osd_uuids = 1; + for (int i = 0; i < this->osd_uuids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(i).data(), this->osd_uuids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1, this->osd_uuids(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_get_suitable_osdsResponse::ByteSize() const { + int total_size = 0; + + // repeated string osd_uuids = 1; + total_size += 1 * this->osd_uuids_size(); + for (int i = 0; i < this->osd_uuids_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->osd_uuids(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_get_suitable_osdsResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_get_suitable_osdsResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_get_suitable_osdsResponse::MergeFrom(const xtreemfs_get_suitable_osdsResponse& from) { + GOOGLE_CHECK_NE(&from, this); + osd_uuids_.MergeFrom(from.osd_uuids_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_get_suitable_osdsResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_get_suitable_osdsResponse::CopyFrom(const xtreemfs_get_suitable_osdsResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_get_suitable_osdsResponse::IsInitialized() const { + + return true; +} + +void xtreemfs_get_suitable_osdsResponse::Swap(xtreemfs_get_suitable_osdsResponse* other) { + if (other != this) { + osd_uuids_.Swap(&other->osd_uuids_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_get_suitable_osdsResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_get_suitable_osdsResponse_descriptor_; + metadata.reflection = xtreemfs_get_suitable_osdsResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int timestampResponse::kTimestampSFieldNumber; +#endif // !_MSC_VER + +timestampResponse::timestampResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void timestampResponse::InitAsDefaultInstance() { +} + +timestampResponse::timestampResponse(const timestampResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void timestampResponse::SharedCtor() { + _cached_size_ = 0; + timestamp_s_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +timestampResponse::~timestampResponse() { + SharedDtor(); +} + +void timestampResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void timestampResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* timestampResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return timestampResponse_descriptor_; +} + +const timestampResponse& timestampResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +timestampResponse* timestampResponse::default_instance_ = NULL; + +timestampResponse* timestampResponse::New() const { + return new timestampResponse; +} + +void timestampResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + timestamp_s_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool timestampResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 timestamp_s = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, ×tamp_s_))); + set_has_timestamp_s(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void timestampResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->timestamp_s(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* timestampResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->timestamp_s(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int timestampResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 timestamp_s = 1; + if (has_timestamp_s()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void timestampResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const timestampResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void timestampResponse::MergeFrom(const timestampResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_timestamp_s()) { + set_timestamp_s(from.timestamp_s()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void timestampResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void timestampResponse::CopyFrom(const timestampResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool timestampResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void timestampResponse::Swap(timestampResponse* other) { + if (other != this) { + std::swap(timestamp_s_, other->timestamp_s_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata timestampResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = timestampResponse_descriptor_; + metadata.reflection = timestampResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int stringMessage::kAStringFieldNumber; +#endif // !_MSC_VER + +stringMessage::stringMessage() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void stringMessage::InitAsDefaultInstance() { +} + +stringMessage::stringMessage(const stringMessage& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void stringMessage::SharedCtor() { + _cached_size_ = 0; + a_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +stringMessage::~stringMessage() { + SharedDtor(); +} + +void stringMessage::SharedDtor() { + if (a_string_ != &::google::protobuf::internal::kEmptyString) { + delete a_string_; + } + if (this != default_instance_) { + } +} + +void stringMessage::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* stringMessage::descriptor() { + protobuf_AssignDescriptorsOnce(); + return stringMessage_descriptor_; +} + +const stringMessage& stringMessage::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +stringMessage* stringMessage::default_instance_ = NULL; + +stringMessage* stringMessage::New() const { + return new stringMessage; +} + +void stringMessage::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_a_string()) { + if (a_string_ != &::google::protobuf::internal::kEmptyString) { + a_string_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool stringMessage::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string a_string = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_a_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->a_string().data(), this->a_string().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void stringMessage::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string a_string = 1; + if (has_a_string()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->a_string().data(), this->a_string().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->a_string(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* stringMessage::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string a_string = 1; + if (has_a_string()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->a_string().data(), this->a_string().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->a_string(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int stringMessage::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string a_string = 1; + if (has_a_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->a_string()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void stringMessage::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const stringMessage* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void stringMessage::MergeFrom(const stringMessage& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_a_string()) { + set_a_string(from.a_string()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void stringMessage::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void stringMessage::CopyFrom(const stringMessage& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool stringMessage::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void stringMessage::Swap(stringMessage* other) { + if (other != this) { + std::swap(a_string_, other->a_string_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata stringMessage::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = stringMessage_descriptor_; + metadata.reflection = stringMessage_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_listdirRequest::kPathFieldNumber; +#endif // !_MSC_VER + +xtreemfs_listdirRequest::xtreemfs_listdirRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_listdirRequest::InitAsDefaultInstance() { +} + +xtreemfs_listdirRequest::xtreemfs_listdirRequest(const xtreemfs_listdirRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_listdirRequest::SharedCtor() { + _cached_size_ = 0; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_listdirRequest::~xtreemfs_listdirRequest() { + SharedDtor(); +} + +void xtreemfs_listdirRequest::SharedDtor() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_listdirRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_listdirRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_listdirRequest_descriptor_; +} + +const xtreemfs_listdirRequest& xtreemfs_listdirRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_listdirRequest* xtreemfs_listdirRequest::default_instance_ = NULL; + +xtreemfs_listdirRequest* xtreemfs_listdirRequest::New() const { + return new xtreemfs_listdirRequest; +} + +void xtreemfs_listdirRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_listdirRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string path = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_listdirRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string path = 1; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->path(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_listdirRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string path = 1; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->path(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_listdirRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string path = 1; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_listdirRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_listdirRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_listdirRequest::MergeFrom(const xtreemfs_listdirRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_path()) { + set_path(from.path()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_listdirRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_listdirRequest::CopyFrom(const xtreemfs_listdirRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_listdirRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_listdirRequest::Swap(xtreemfs_listdirRequest* other) { + if (other != this) { + std::swap(path_, other->path_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_listdirRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_listdirRequest_descriptor_; + metadata.reflection = xtreemfs_listdirRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_listdirResponse::kNamesFieldNumber; +#endif // !_MSC_VER + +xtreemfs_listdirResponse::xtreemfs_listdirResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_listdirResponse::InitAsDefaultInstance() { +} + +xtreemfs_listdirResponse::xtreemfs_listdirResponse(const xtreemfs_listdirResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_listdirResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_listdirResponse::~xtreemfs_listdirResponse() { + SharedDtor(); +} + +void xtreemfs_listdirResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_listdirResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_listdirResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_listdirResponse_descriptor_; +} + +const xtreemfs_listdirResponse& xtreemfs_listdirResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_listdirResponse* xtreemfs_listdirResponse::default_instance_ = NULL; + +xtreemfs_listdirResponse* xtreemfs_listdirResponse::New() const { + return new xtreemfs_listdirResponse; +} + +void xtreemfs_listdirResponse::Clear() { + names_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_listdirResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string names = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_names: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_names())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->names(this->names_size() - 1).data(), + this->names(this->names_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_names; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_listdirResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated string names = 1; + for (int i = 0; i < this->names_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->names(i).data(), this->names(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->names(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_listdirResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated string names = 1; + for (int i = 0; i < this->names_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->names(i).data(), this->names(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1, this->names(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_listdirResponse::ByteSize() const { + int total_size = 0; + + // repeated string names = 1; + total_size += 1 * this->names_size(); + for (int i = 0; i < this->names_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->names(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_listdirResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_listdirResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_listdirResponse::MergeFrom(const xtreemfs_listdirResponse& from) { + GOOGLE_CHECK_NE(&from, this); + names_.MergeFrom(from.names_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_listdirResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_listdirResponse::CopyFrom(const xtreemfs_listdirResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_listdirResponse::IsInitialized() const { + + return true; +} + +void xtreemfs_listdirResponse::Swap(xtreemfs_listdirResponse* other) { + if (other != this) { + names_.Swap(&other->names_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_listdirResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_listdirResponse_descriptor_; + metadata.reflection = xtreemfs_listdirResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_replica_addRequest::kFileIdFieldNumber; +const int xtreemfs_replica_addRequest::kPathFieldNumber; +const int xtreemfs_replica_addRequest::kVolumeNameFieldNumber; +const int xtreemfs_replica_addRequest::kNewReplicaFieldNumber; +#endif // !_MSC_VER + +xtreemfs_replica_addRequest::xtreemfs_replica_addRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_replica_addRequest::InitAsDefaultInstance() { + new_replica_ = const_cast< ::xtreemfs::pbrpc::Replica*>(&::xtreemfs::pbrpc::Replica::default_instance()); +} + +xtreemfs_replica_addRequest::xtreemfs_replica_addRequest(const xtreemfs_replica_addRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_replica_addRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + new_replica_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_replica_addRequest::~xtreemfs_replica_addRequest() { + SharedDtor(); +} + +void xtreemfs_replica_addRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (this != default_instance_) { + delete new_replica_; + } +} + +void xtreemfs_replica_addRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_replica_addRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_replica_addRequest_descriptor_; +} + +const xtreemfs_replica_addRequest& xtreemfs_replica_addRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_replica_addRequest* xtreemfs_replica_addRequest::default_instance_ = NULL; + +xtreemfs_replica_addRequest* xtreemfs_replica_addRequest::New() const { + return new xtreemfs_replica_addRequest; +} + +void xtreemfs_replica_addRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_new_replica()) { + if (new_replica_ != NULL) new_replica_->::xtreemfs::pbrpc::Replica::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_replica_addRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_new_replica; + break; + } + + // required .xtreemfs.pbrpc.Replica new_replica = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_new_replica: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_new_replica())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_path; + break; + } + + // optional string path = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_volume_name; + break; + } + + // optional string volume_name = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_volume_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_replica_addRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + // required .xtreemfs.pbrpc.Replica new_replica = 2; + if (has_new_replica()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->new_replica(), output); + } + + // optional string path = 3; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->path(), output); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->volume_name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_replica_addRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + // required .xtreemfs.pbrpc.Replica new_replica = 2; + if (has_new_replica()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->new_replica(), target); + } + + // optional string path = 3; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->path(), target); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->volume_name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_replica_addRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // optional string path = 3; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required .xtreemfs.pbrpc.Replica new_replica = 2; + if (has_new_replica()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->new_replica()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_replica_addRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_replica_addRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_replica_addRequest::MergeFrom(const xtreemfs_replica_addRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_new_replica()) { + mutable_new_replica()->::xtreemfs::pbrpc::Replica::MergeFrom(from.new_replica()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_replica_addRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_replica_addRequest::CopyFrom(const xtreemfs_replica_addRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_replica_addRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false; + + if (has_new_replica()) { + if (!this->new_replica().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_replica_addRequest::Swap(xtreemfs_replica_addRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(path_, other->path_); + std::swap(volume_name_, other->volume_name_); + std::swap(new_replica_, other->new_replica_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_replica_addRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_replica_addRequest_descriptor_; + metadata.reflection = xtreemfs_replica_addRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_replica_listRequest::kFileIdFieldNumber; +const int xtreemfs_replica_listRequest::kPathFieldNumber; +const int xtreemfs_replica_listRequest::kVolumeNameFieldNumber; +#endif // !_MSC_VER + +xtreemfs_replica_listRequest::xtreemfs_replica_listRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_replica_listRequest::InitAsDefaultInstance() { +} + +xtreemfs_replica_listRequest::xtreemfs_replica_listRequest(const xtreemfs_replica_listRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_replica_listRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_replica_listRequest::~xtreemfs_replica_listRequest() { + SharedDtor(); +} + +void xtreemfs_replica_listRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_replica_listRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_replica_listRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_replica_listRequest_descriptor_; +} + +const xtreemfs_replica_listRequest& xtreemfs_replica_listRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_replica_listRequest* xtreemfs_replica_listRequest::default_instance_ = NULL; + +xtreemfs_replica_listRequest* xtreemfs_replica_listRequest::New() const { + return new xtreemfs_replica_listRequest; +} + +void xtreemfs_replica_listRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_replica_listRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // optional string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_volume_name; + break; + } + + // optional string volume_name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_volume_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_replica_listRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + // optional string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // optional string volume_name = 3; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->volume_name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_replica_listRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + // optional string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // optional string volume_name = 3; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->volume_name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_replica_listRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // optional string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // optional string volume_name = 3; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_replica_listRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_replica_listRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_replica_listRequest::MergeFrom(const xtreemfs_replica_listRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_replica_listRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_replica_listRequest::CopyFrom(const xtreemfs_replica_listRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_replica_listRequest::IsInitialized() const { + + return true; +} + +void xtreemfs_replica_listRequest::Swap(xtreemfs_replica_listRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(path_, other->path_); + std::swap(volume_name_, other->volume_name_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_replica_listRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_replica_listRequest_descriptor_; + metadata.reflection = xtreemfs_replica_listRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_get_xlocsetRequest::kFileIdFieldNumber; +const int xtreemfs_get_xlocsetRequest::kPathFieldNumber; +const int xtreemfs_get_xlocsetRequest::kVolumeNameFieldNumber; +const int xtreemfs_get_xlocsetRequest::kXcapFieldNumber; +#endif // !_MSC_VER + +xtreemfs_get_xlocsetRequest::xtreemfs_get_xlocsetRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_get_xlocsetRequest::InitAsDefaultInstance() { + xcap_ = const_cast< ::xtreemfs::pbrpc::XCap*>(&::xtreemfs::pbrpc::XCap::default_instance()); +} + +xtreemfs_get_xlocsetRequest::xtreemfs_get_xlocsetRequest(const xtreemfs_get_xlocsetRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_get_xlocsetRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + xcap_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_get_xlocsetRequest::~xtreemfs_get_xlocsetRequest() { + SharedDtor(); +} + +void xtreemfs_get_xlocsetRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (this != default_instance_) { + delete xcap_; + } +} + +void xtreemfs_get_xlocsetRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_get_xlocsetRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_get_xlocsetRequest_descriptor_; +} + +const xtreemfs_get_xlocsetRequest& xtreemfs_get_xlocsetRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_get_xlocsetRequest* xtreemfs_get_xlocsetRequest::default_instance_ = NULL; + +xtreemfs_get_xlocsetRequest* xtreemfs_get_xlocsetRequest::New() const { + return new xtreemfs_get_xlocsetRequest; +} + +void xtreemfs_get_xlocsetRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_xcap()) { + if (xcap_ != NULL) xcap_->::xtreemfs::pbrpc::XCap::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_get_xlocsetRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_path; + break; + } + + // optional string path = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_volume_name; + break; + } + + // optional string volume_name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_volume_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_xcap; + break; + } + + // optional .xtreemfs.pbrpc.XCap xcap = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_xcap: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_xcap())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_get_xlocsetRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + // optional string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->path(), output); + } + + // optional string volume_name = 3; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->volume_name(), output); + } + + // optional .xtreemfs.pbrpc.XCap xcap = 4; + if (has_xcap()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->xcap(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_get_xlocsetRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + // optional string path = 2; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->path(), target); + } + + // optional string volume_name = 3; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->volume_name(), target); + } + + // optional .xtreemfs.pbrpc.XCap xcap = 4; + if (has_xcap()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->xcap(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_get_xlocsetRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // optional string path = 2; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // optional string volume_name = 3; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // optional .xtreemfs.pbrpc.XCap xcap = 4; + if (has_xcap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->xcap()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_get_xlocsetRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_get_xlocsetRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_get_xlocsetRequest::MergeFrom(const xtreemfs_get_xlocsetRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_xcap()) { + mutable_xcap()->::xtreemfs::pbrpc::XCap::MergeFrom(from.xcap()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_get_xlocsetRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_get_xlocsetRequest::CopyFrom(const xtreemfs_get_xlocsetRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_get_xlocsetRequest::IsInitialized() const { + + if (has_xcap()) { + if (!this->xcap().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_get_xlocsetRequest::Swap(xtreemfs_get_xlocsetRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(path_, other->path_); + std::swap(volume_name_, other->volume_name_); + std::swap(xcap_, other->xcap_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_get_xlocsetRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_get_xlocsetRequest_descriptor_; + metadata.reflection = xtreemfs_get_xlocsetRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_replica_removeRequest::kFileIdFieldNumber; +const int xtreemfs_replica_removeRequest::kPathFieldNumber; +const int xtreemfs_replica_removeRequest::kVolumeNameFieldNumber; +const int xtreemfs_replica_removeRequest::kOsdUuidFieldNumber; +#endif // !_MSC_VER + +xtreemfs_replica_removeRequest::xtreemfs_replica_removeRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_replica_removeRequest::InitAsDefaultInstance() { +} + +xtreemfs_replica_removeRequest::xtreemfs_replica_removeRequest(const xtreemfs_replica_removeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_replica_removeRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_replica_removeRequest::~xtreemfs_replica_removeRequest() { + SharedDtor(); +} + +void xtreemfs_replica_removeRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete osd_uuid_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_replica_removeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_replica_removeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_replica_removeRequest_descriptor_; +} + +const xtreemfs_replica_removeRequest& xtreemfs_replica_removeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_replica_removeRequest* xtreemfs_replica_removeRequest::default_instance_ = NULL; + +xtreemfs_replica_removeRequest* xtreemfs_replica_removeRequest::New() const { + return new xtreemfs_replica_removeRequest; +} + +void xtreemfs_replica_removeRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + if (has_path()) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + } + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + if (has_osd_uuid()) { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + osd_uuid_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_replica_removeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_osd_uuid; + break; + } + + // required string osd_uuid = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_osd_uuid: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_osd_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_path; + break; + } + + // optional string path = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_volume_name; + break; + } + + // optional string volume_name = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_volume_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_replica_removeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + // required string osd_uuid = 2; + if (has_osd_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->osd_uuid(), output); + } + + // optional string path = 3; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->path(), output); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->volume_name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_replica_removeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + // required string osd_uuid = 2; + if (has_osd_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->osd_uuid(), target); + } + + // optional string path = 3; + if (has_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->path().data(), this->path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->path(), target); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->volume_name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_replica_removeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // optional string path = 3; + if (has_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->path()); + } + + // optional string volume_name = 4; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + // required string osd_uuid = 2; + if (has_osd_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->osd_uuid()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_replica_removeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_replica_removeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_replica_removeRequest::MergeFrom(const xtreemfs_replica_removeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_path()) { + set_path(from.path()); + } + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + if (from.has_osd_uuid()) { + set_osd_uuid(from.osd_uuid()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_replica_removeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_replica_removeRequest::CopyFrom(const xtreemfs_replica_removeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_replica_removeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false; + + return true; +} + +void xtreemfs_replica_removeRequest::Swap(xtreemfs_replica_removeRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(path_, other->path_); + std::swap(volume_name_, other->volume_name_); + std::swap(osd_uuid_, other->osd_uuid_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_replica_removeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_replica_removeRequest_descriptor_; + metadata.reflection = xtreemfs_replica_removeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_restore_fileRequest::kFilePathFieldNumber; +const int xtreemfs_restore_fileRequest::kFileIdFieldNumber; +const int xtreemfs_restore_fileRequest::kFileSizeFieldNumber; +const int xtreemfs_restore_fileRequest::kOsdUuidFieldNumber; +const int xtreemfs_restore_fileRequest::kStripeSizeFieldNumber; +#endif // !_MSC_VER + +xtreemfs_restore_fileRequest::xtreemfs_restore_fileRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_restore_fileRequest::InitAsDefaultInstance() { +} + +xtreemfs_restore_fileRequest::xtreemfs_restore_fileRequest(const xtreemfs_restore_fileRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_restore_fileRequest::SharedCtor() { + _cached_size_ = 0; + file_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + file_size_ = GOOGLE_ULONGLONG(0); + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + stripe_size_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_restore_fileRequest::~xtreemfs_restore_fileRequest() { + SharedDtor(); +} + +void xtreemfs_restore_fileRequest::SharedDtor() { + if (file_path_ != &::google::protobuf::internal::kEmptyString) { + delete file_path_; + } + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete osd_uuid_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_restore_fileRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_restore_fileRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_restore_fileRequest_descriptor_; +} + +const xtreemfs_restore_fileRequest& xtreemfs_restore_fileRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_restore_fileRequest* xtreemfs_restore_fileRequest::default_instance_ = NULL; + +xtreemfs_restore_fileRequest* xtreemfs_restore_fileRequest::New() const { + return new xtreemfs_restore_fileRequest; +} + +void xtreemfs_restore_fileRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_path()) { + if (file_path_ != &::google::protobuf::internal::kEmptyString) { + file_path_->clear(); + } + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + file_size_ = GOOGLE_ULONGLONG(0); + if (has_osd_uuid()) { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + osd_uuid_->clear(); + } + } + stripe_size_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_restore_fileRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string file_path = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_path())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_path().data(), this->file_path().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_file_size; + break; + } + + // required fixed64 file_size = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_file_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &file_size_))); + set_has_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_osd_uuid; + break; + } + + // required string osd_uuid = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_osd_uuid: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_osd_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_stripe_size; + break; + } + + // required fixed32 stripe_size = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_stripe_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &stripe_size_))); + set_has_stripe_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_restore_fileRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string file_path = 1; + if (has_file_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_path().data(), this->file_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_path(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 file_size = 3; + if (has_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->file_size(), output); + } + + // required string osd_uuid = 4; + if (has_osd_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->osd_uuid(), output); + } + + // required fixed32 stripe_size = 5; + if (has_stripe_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->stripe_size(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_restore_fileRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string file_path = 1; + if (has_file_path()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_path().data(), this->file_path().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_path(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 file_size = 3; + if (has_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->file_size(), target); + } + + // required string osd_uuid = 4; + if (has_osd_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuid().data(), this->osd_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->osd_uuid(), target); + } + + // required fixed32 stripe_size = 5; + if (has_stripe_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->stripe_size(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_restore_fileRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string file_path = 1; + if (has_file_path()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_path()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 file_size = 3; + if (has_file_size()) { + total_size += 1 + 8; + } + + // required string osd_uuid = 4; + if (has_osd_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->osd_uuid()); + } + + // required fixed32 stripe_size = 5; + if (has_stripe_size()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_restore_fileRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_restore_fileRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_restore_fileRequest::MergeFrom(const xtreemfs_restore_fileRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_path()) { + set_file_path(from.file_path()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_file_size()) { + set_file_size(from.file_size()); + } + if (from.has_osd_uuid()) { + set_osd_uuid(from.osd_uuid()); + } + if (from.has_stripe_size()) { + set_stripe_size(from.stripe_size()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_restore_fileRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_restore_fileRequest::CopyFrom(const xtreemfs_restore_fileRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_restore_fileRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false; + + return true; +} + +void xtreemfs_restore_fileRequest::Swap(xtreemfs_restore_fileRequest* other) { + if (other != this) { + std::swap(file_path_, other->file_path_); + std::swap(file_id_, other->file_id_); + std::swap(file_size_, other->file_size_); + std::swap(osd_uuid_, other->osd_uuid_); + std::swap(stripe_size_, other->stripe_size_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_restore_fileRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_restore_fileRequest_descriptor_; + metadata.reflection = xtreemfs_restore_fileRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rmvolRequest::kVolumeNameFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rmvolRequest::xtreemfs_rmvolRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rmvolRequest::InitAsDefaultInstance() { +} + +xtreemfs_rmvolRequest::xtreemfs_rmvolRequest(const xtreemfs_rmvolRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rmvolRequest::SharedCtor() { + _cached_size_ = 0; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rmvolRequest::~xtreemfs_rmvolRequest() { + SharedDtor(); +} + +void xtreemfs_rmvolRequest::SharedDtor() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_rmvolRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rmvolRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rmvolRequest_descriptor_; +} + +const xtreemfs_rmvolRequest& xtreemfs_rmvolRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_rmvolRequest* xtreemfs_rmvolRequest::default_instance_ = NULL; + +xtreemfs_rmvolRequest* xtreemfs_rmvolRequest::New() const { + return new xtreemfs_rmvolRequest; +} + +void xtreemfs_rmvolRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_volume_name()) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rmvolRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string volume_name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_volume_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rmvolRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->volume_name(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rmvolRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string volume_name = 1; + if (has_volume_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->volume_name().data(), this->volume_name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->volume_name(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rmvolRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string volume_name = 1; + if (has_volume_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->volume_name()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rmvolRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rmvolRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rmvolRequest::MergeFrom(const xtreemfs_rmvolRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_volume_name()) { + set_volume_name(from.volume_name()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rmvolRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rmvolRequest::CopyFrom(const xtreemfs_rmvolRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rmvolRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_rmvolRequest::Swap(xtreemfs_rmvolRequest* other) { + if (other != this) { + std::swap(volume_name_, other->volume_name_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rmvolRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rmvolRequest_descriptor_; + metadata.reflection = xtreemfs_rmvolRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_update_file_sizeRequest::kXcapFieldNumber; +const int xtreemfs_update_file_sizeRequest::kOsdWriteResponseFieldNumber; +const int xtreemfs_update_file_sizeRequest::kCloseFileFieldNumber; +const int xtreemfs_update_file_sizeRequest::kCoordinatesFieldNumber; +#endif // !_MSC_VER + +xtreemfs_update_file_sizeRequest::xtreemfs_update_file_sizeRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_update_file_sizeRequest::InitAsDefaultInstance() { + xcap_ = const_cast< ::xtreemfs::pbrpc::XCap*>(&::xtreemfs::pbrpc::XCap::default_instance()); + osd_write_response_ = const_cast< ::xtreemfs::pbrpc::OSDWriteResponse*>(&::xtreemfs::pbrpc::OSDWriteResponse::default_instance()); + coordinates_ = const_cast< ::xtreemfs::pbrpc::VivaldiCoordinates*>(&::xtreemfs::pbrpc::VivaldiCoordinates::default_instance()); +} + +xtreemfs_update_file_sizeRequest::xtreemfs_update_file_sizeRequest(const xtreemfs_update_file_sizeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_update_file_sizeRequest::SharedCtor() { + _cached_size_ = 0; + xcap_ = NULL; + osd_write_response_ = NULL; + close_file_ = false; + coordinates_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_update_file_sizeRequest::~xtreemfs_update_file_sizeRequest() { + SharedDtor(); +} + +void xtreemfs_update_file_sizeRequest::SharedDtor() { + if (this != default_instance_) { + delete xcap_; + delete osd_write_response_; + delete coordinates_; + } +} + +void xtreemfs_update_file_sizeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_update_file_sizeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_update_file_sizeRequest_descriptor_; +} + +const xtreemfs_update_file_sizeRequest& xtreemfs_update_file_sizeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_update_file_sizeRequest* xtreemfs_update_file_sizeRequest::default_instance_ = NULL; + +xtreemfs_update_file_sizeRequest* xtreemfs_update_file_sizeRequest::New() const { + return new xtreemfs_update_file_sizeRequest; +} + +void xtreemfs_update_file_sizeRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_xcap()) { + if (xcap_ != NULL) xcap_->::xtreemfs::pbrpc::XCap::Clear(); + } + if (has_osd_write_response()) { + if (osd_write_response_ != NULL) osd_write_response_->::xtreemfs::pbrpc::OSDWriteResponse::Clear(); + } + close_file_ = false; + if (has_coordinates()) { + if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_update_file_sizeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.XCap xcap = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_xcap())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_osd_write_response; + break; + } + + // required .xtreemfs.pbrpc.OSDWriteResponse osd_write_response = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_osd_write_response: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_osd_write_response())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_close_file; + break; + } + + // optional bool close_file = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_close_file: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &close_file_))); + set_has_close_file(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_coordinates; + break; + } + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_coordinates: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_coordinates())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_update_file_sizeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.XCap xcap = 1; + if (has_xcap()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->xcap(), output); + } + + // required .xtreemfs.pbrpc.OSDWriteResponse osd_write_response = 2; + if (has_osd_write_response()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->osd_write_response(), output); + } + + // optional bool close_file = 3; + if (has_close_file()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->close_file(), output); + } + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 4; + if (has_coordinates()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->coordinates(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_update_file_sizeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.XCap xcap = 1; + if (has_xcap()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->xcap(), target); + } + + // required .xtreemfs.pbrpc.OSDWriteResponse osd_write_response = 2; + if (has_osd_write_response()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->osd_write_response(), target); + } + + // optional bool close_file = 3; + if (has_close_file()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->close_file(), target); + } + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 4; + if (has_coordinates()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->coordinates(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_update_file_sizeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.XCap xcap = 1; + if (has_xcap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->xcap()); + } + + // required .xtreemfs.pbrpc.OSDWriteResponse osd_write_response = 2; + if (has_osd_write_response()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->osd_write_response()); + } + + // optional bool close_file = 3; + if (has_close_file()) { + total_size += 1 + 1; + } + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 4; + if (has_coordinates()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->coordinates()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_update_file_sizeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_update_file_sizeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_update_file_sizeRequest::MergeFrom(const xtreemfs_update_file_sizeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_xcap()) { + mutable_xcap()->::xtreemfs::pbrpc::XCap::MergeFrom(from.xcap()); + } + if (from.has_osd_write_response()) { + mutable_osd_write_response()->::xtreemfs::pbrpc::OSDWriteResponse::MergeFrom(from.osd_write_response()); + } + if (from.has_close_file()) { + set_close_file(from.close_file()); + } + if (from.has_coordinates()) { + mutable_coordinates()->::xtreemfs::pbrpc::VivaldiCoordinates::MergeFrom(from.coordinates()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_update_file_sizeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_update_file_sizeRequest::CopyFrom(const xtreemfs_update_file_sizeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_update_file_sizeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_xcap()) { + if (!this->xcap().IsInitialized()) return false; + } + if (has_coordinates()) { + if (!this->coordinates().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_update_file_sizeRequest::Swap(xtreemfs_update_file_sizeRequest* other) { + if (other != this) { + std::swap(xcap_, other->xcap_); + std::swap(osd_write_response_, other->osd_write_response_); + std::swap(close_file_, other->close_file_); + std::swap(coordinates_, other->coordinates_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_update_file_sizeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_update_file_sizeRequest_descriptor_; + metadata.reflection = xtreemfs_update_file_sizeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_set_replica_update_policyRequest::kFileIdFieldNumber; +const int xtreemfs_set_replica_update_policyRequest::kUpdatePolicyFieldNumber; +#endif // !_MSC_VER + +xtreemfs_set_replica_update_policyRequest::xtreemfs_set_replica_update_policyRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_set_replica_update_policyRequest::InitAsDefaultInstance() { +} + +xtreemfs_set_replica_update_policyRequest::xtreemfs_set_replica_update_policyRequest(const xtreemfs_set_replica_update_policyRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_set_replica_update_policyRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_set_replica_update_policyRequest::~xtreemfs_set_replica_update_policyRequest() { + SharedDtor(); +} + +void xtreemfs_set_replica_update_policyRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (update_policy_ != &::google::protobuf::internal::kEmptyString) { + delete update_policy_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_set_replica_update_policyRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_set_replica_update_policyRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_set_replica_update_policyRequest_descriptor_; +} + +const xtreemfs_set_replica_update_policyRequest& xtreemfs_set_replica_update_policyRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_set_replica_update_policyRequest* xtreemfs_set_replica_update_policyRequest::default_instance_ = NULL; + +xtreemfs_set_replica_update_policyRequest* xtreemfs_set_replica_update_policyRequest::New() const { + return new xtreemfs_set_replica_update_policyRequest; +} + +void xtreemfs_set_replica_update_policyRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + if (has_update_policy()) { + if (update_policy_ != &::google::protobuf::internal::kEmptyString) { + update_policy_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_set_replica_update_policyRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_update_policy; + break; + } + + // required string update_policy = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_update_policy: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_update_policy())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->update_policy().data(), this->update_policy().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_set_replica_update_policyRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + // required string update_policy = 2; + if (has_update_policy()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->update_policy().data(), this->update_policy().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->update_policy(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_set_replica_update_policyRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + // required string update_policy = 2; + if (has_update_policy()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->update_policy().data(), this->update_policy().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->update_policy(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_set_replica_update_policyRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required string update_policy = 2; + if (has_update_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->update_policy()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_set_replica_update_policyRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_set_replica_update_policyRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_set_replica_update_policyRequest::MergeFrom(const xtreemfs_set_replica_update_policyRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_update_policy()) { + set_update_policy(from.update_policy()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_set_replica_update_policyRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_set_replica_update_policyRequest::CopyFrom(const xtreemfs_set_replica_update_policyRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_set_replica_update_policyRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void xtreemfs_set_replica_update_policyRequest::Swap(xtreemfs_set_replica_update_policyRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(update_policy_, other->update_policy_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_set_replica_update_policyRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_set_replica_update_policyRequest_descriptor_; + metadata.reflection = xtreemfs_set_replica_update_policyRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_set_replica_update_policyResponse::kOldUpdatePolicyFieldNumber; +#endif // !_MSC_VER + +xtreemfs_set_replica_update_policyResponse::xtreemfs_set_replica_update_policyResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_set_replica_update_policyResponse::InitAsDefaultInstance() { +} + +xtreemfs_set_replica_update_policyResponse::xtreemfs_set_replica_update_policyResponse(const xtreemfs_set_replica_update_policyResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_set_replica_update_policyResponse::SharedCtor() { + _cached_size_ = 0; + old_update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_set_replica_update_policyResponse::~xtreemfs_set_replica_update_policyResponse() { + SharedDtor(); +} + +void xtreemfs_set_replica_update_policyResponse::SharedDtor() { + if (old_update_policy_ != &::google::protobuf::internal::kEmptyString) { + delete old_update_policy_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_set_replica_update_policyResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_set_replica_update_policyResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_set_replica_update_policyResponse_descriptor_; +} + +const xtreemfs_set_replica_update_policyResponse& xtreemfs_set_replica_update_policyResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_set_replica_update_policyResponse* xtreemfs_set_replica_update_policyResponse::default_instance_ = NULL; + +xtreemfs_set_replica_update_policyResponse* xtreemfs_set_replica_update_policyResponse::New() const { + return new xtreemfs_set_replica_update_policyResponse; +} + +void xtreemfs_set_replica_update_policyResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_old_update_policy()) { + if (old_update_policy_ != &::google::protobuf::internal::kEmptyString) { + old_update_policy_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_set_replica_update_policyResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string old_update_policy = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_old_update_policy())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->old_update_policy().data(), this->old_update_policy().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_set_replica_update_policyResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string old_update_policy = 1; + if (has_old_update_policy()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->old_update_policy().data(), this->old_update_policy().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->old_update_policy(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_set_replica_update_policyResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string old_update_policy = 1; + if (has_old_update_policy()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->old_update_policy().data(), this->old_update_policy().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->old_update_policy(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_set_replica_update_policyResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string old_update_policy = 1; + if (has_old_update_policy()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->old_update_policy()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_set_replica_update_policyResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_set_replica_update_policyResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_set_replica_update_policyResponse::MergeFrom(const xtreemfs_set_replica_update_policyResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_old_update_policy()) { + set_old_update_policy(from.old_update_policy()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_set_replica_update_policyResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_set_replica_update_policyResponse::CopyFrom(const xtreemfs_set_replica_update_policyResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_set_replica_update_policyResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_set_replica_update_policyResponse::Swap(xtreemfs_set_replica_update_policyResponse* other) { + if (other != this) { + std::swap(old_update_policy_, other->old_update_policy_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_set_replica_update_policyResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_set_replica_update_policyResponse_descriptor_; + metadata.reflection = xtreemfs_set_replica_update_policyResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_set_read_only_xattrRequest::kFileIdFieldNumber; +const int xtreemfs_set_read_only_xattrRequest::kValueFieldNumber; +#endif // !_MSC_VER + +xtreemfs_set_read_only_xattrRequest::xtreemfs_set_read_only_xattrRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_set_read_only_xattrRequest::InitAsDefaultInstance() { +} + +xtreemfs_set_read_only_xattrRequest::xtreemfs_set_read_only_xattrRequest(const xtreemfs_set_read_only_xattrRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_set_read_only_xattrRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + value_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_set_read_only_xattrRequest::~xtreemfs_set_read_only_xattrRequest() { + SharedDtor(); +} + +void xtreemfs_set_read_only_xattrRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_set_read_only_xattrRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_set_read_only_xattrRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_set_read_only_xattrRequest_descriptor_; +} + +const xtreemfs_set_read_only_xattrRequest& xtreemfs_set_read_only_xattrRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_set_read_only_xattrRequest* xtreemfs_set_read_only_xattrRequest::default_instance_ = NULL; + +xtreemfs_set_read_only_xattrRequest* xtreemfs_set_read_only_xattrRequest::New() const { + return new xtreemfs_set_read_only_xattrRequest; +} + +void xtreemfs_set_read_only_xattrRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + value_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_set_read_only_xattrRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_value; + break; + } + + // required bool value = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_value: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &value_))); + set_has_value(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_set_read_only_xattrRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + // required bool value = 2; + if (has_value()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->value(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_set_read_only_xattrRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + // required bool value = 2; + if (has_value()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->value(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_set_read_only_xattrRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required bool value = 2; + if (has_value()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_set_read_only_xattrRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_set_read_only_xattrRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_set_read_only_xattrRequest::MergeFrom(const xtreemfs_set_read_only_xattrRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_value()) { + set_value(from.value()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_set_read_only_xattrRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_set_read_only_xattrRequest::CopyFrom(const xtreemfs_set_read_only_xattrRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_set_read_only_xattrRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void xtreemfs_set_read_only_xattrRequest::Swap(xtreemfs_set_read_only_xattrRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(value_, other->value_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_set_read_only_xattrRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_set_read_only_xattrRequest_descriptor_; + metadata.reflection = xtreemfs_set_read_only_xattrRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_set_read_only_xattrResponse::kWasSetFieldNumber; +#endif // !_MSC_VER + +xtreemfs_set_read_only_xattrResponse::xtreemfs_set_read_only_xattrResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_set_read_only_xattrResponse::InitAsDefaultInstance() { +} + +xtreemfs_set_read_only_xattrResponse::xtreemfs_set_read_only_xattrResponse(const xtreemfs_set_read_only_xattrResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_set_read_only_xattrResponse::SharedCtor() { + _cached_size_ = 0; + was_set_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_set_read_only_xattrResponse::~xtreemfs_set_read_only_xattrResponse() { + SharedDtor(); +} + +void xtreemfs_set_read_only_xattrResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_set_read_only_xattrResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_set_read_only_xattrResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_set_read_only_xattrResponse_descriptor_; +} + +const xtreemfs_set_read_only_xattrResponse& xtreemfs_set_read_only_xattrResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_set_read_only_xattrResponse* xtreemfs_set_read_only_xattrResponse::default_instance_ = NULL; + +xtreemfs_set_read_only_xattrResponse* xtreemfs_set_read_only_xattrResponse::New() const { + return new xtreemfs_set_read_only_xattrResponse; +} + +void xtreemfs_set_read_only_xattrResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + was_set_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_set_read_only_xattrResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required bool was_set = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &was_set_))); + set_has_was_set(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_set_read_only_xattrResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required bool was_set = 1; + if (has_was_set()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->was_set(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_set_read_only_xattrResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required bool was_set = 1; + if (has_was_set()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->was_set(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_set_read_only_xattrResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required bool was_set = 1; + if (has_was_set()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_set_read_only_xattrResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_set_read_only_xattrResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_set_read_only_xattrResponse::MergeFrom(const xtreemfs_set_read_only_xattrResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_was_set()) { + set_was_set(from.was_set()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_set_read_only_xattrResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_set_read_only_xattrResponse::CopyFrom(const xtreemfs_set_read_only_xattrResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_set_read_only_xattrResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_set_read_only_xattrResponse::Swap(xtreemfs_set_read_only_xattrResponse* other) { + if (other != this) { + std::swap(was_set_, other->was_set_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_set_read_only_xattrResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_set_read_only_xattrResponse_descriptor_; + metadata.reflection = xtreemfs_set_read_only_xattrResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_get_file_credentialsRequest::kFileIdFieldNumber; +#endif // !_MSC_VER + +xtreemfs_get_file_credentialsRequest::xtreemfs_get_file_credentialsRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_get_file_credentialsRequest::InitAsDefaultInstance() { +} + +xtreemfs_get_file_credentialsRequest::xtreemfs_get_file_credentialsRequest(const xtreemfs_get_file_credentialsRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_get_file_credentialsRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_get_file_credentialsRequest::~xtreemfs_get_file_credentialsRequest() { + SharedDtor(); +} + +void xtreemfs_get_file_credentialsRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_get_file_credentialsRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_get_file_credentialsRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_get_file_credentialsRequest_descriptor_; +} + +const xtreemfs_get_file_credentialsRequest& xtreemfs_get_file_credentialsRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + return *default_instance_; +} + +xtreemfs_get_file_credentialsRequest* xtreemfs_get_file_credentialsRequest::default_instance_ = NULL; + +xtreemfs_get_file_credentialsRequest* xtreemfs_get_file_credentialsRequest::New() const { + return new xtreemfs_get_file_credentialsRequest; +} + +void xtreemfs_get_file_credentialsRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_get_file_credentialsRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_get_file_credentialsRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_get_file_credentialsRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_get_file_credentialsRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_get_file_credentialsRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_get_file_credentialsRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_get_file_credentialsRequest::MergeFrom(const xtreemfs_get_file_credentialsRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_get_file_credentialsRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_get_file_credentialsRequest::CopyFrom(const xtreemfs_get_file_credentialsRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_get_file_credentialsRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_get_file_credentialsRequest::Swap(xtreemfs_get_file_credentialsRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_get_file_credentialsRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_get_file_credentialsRequest_descriptor_; + metadata.reflection = xtreemfs_get_file_credentialsRequest_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +// @@protoc_insertion_point(global_scope) diff --git a/cpp/generated/xtreemfs/MRC.pb.h b/cpp/generated/xtreemfs/MRC.pb.h new file mode 100644 index 0000000..29caf1e --- /dev/null +++ b/cpp/generated/xtreemfs/MRC.pb.h @@ -0,0 +1,14469 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: xtreemfs/MRC.proto + +#ifndef PROTOBUF_xtreemfs_2fMRC_2eproto__INCLUDED +#define PROTOBUF_xtreemfs_2fMRC_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2005000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include "include/PBRPC.pb.h" +#include "include/Common.pb.h" +#include "xtreemfs/GlobalTypes.pb.h" +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); +void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); +void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + +class Stat; +class DirectoryEntry; +class DirectoryEntries; +class XAttr; +class Volume; +class Volumes; +class StatVFS; +class fsetattrRequest; +class getattrRequest; +class getattrResponse; +class getxattrRequest; +class getxattrResponse; +class linkRequest; +class listxattrRequest; +class listxattrResponse; +class mkdirRequest; +class openRequest; +class openResponse; +class readdirRequest; +class readlinkRequest; +class readlinkResponse; +class removexattrRequest; +class renameRequest; +class renameResponse; +class rmdirRequest; +class setattrRequest; +class setxattrRequest; +class statvfsRequest; +class symlinkRequest; +class unlinkRequest; +class unlinkResponse; +class accessRequest; +class xtreemfs_check_file_existsRequest; +class xtreemfs_check_file_existsResponse; +class xtreemfs_dump_restore_databaseRequest; +class xtreemfs_get_suitable_osdsRequest; +class xtreemfs_get_suitable_osdsResponse; +class timestampResponse; +class stringMessage; +class xtreemfs_listdirRequest; +class xtreemfs_listdirResponse; +class xtreemfs_replica_addRequest; +class xtreemfs_replica_listRequest; +class xtreemfs_get_xlocsetRequest; +class xtreemfs_replica_removeRequest; +class xtreemfs_restore_fileRequest; +class xtreemfs_rmvolRequest; +class xtreemfs_update_file_sizeRequest; +class xtreemfs_set_replica_update_policyRequest; +class xtreemfs_set_replica_update_policyResponse; +class xtreemfs_set_read_only_xattrRequest; +class xtreemfs_set_read_only_xattrResponse; +class xtreemfs_get_file_credentialsRequest; + +enum xtreemfs_check_file_existsResponse_FILE_STATE { + xtreemfs_check_file_existsResponse_FILE_STATE_DELETED = 0, + xtreemfs_check_file_existsResponse_FILE_STATE_REGISTERED = 1, + xtreemfs_check_file_existsResponse_FILE_STATE_ABANDONED = 2 +}; +bool xtreemfs_check_file_existsResponse_FILE_STATE_IsValid(int value); +const xtreemfs_check_file_existsResponse_FILE_STATE xtreemfs_check_file_existsResponse_FILE_STATE_FILE_STATE_MIN = xtreemfs_check_file_existsResponse_FILE_STATE_DELETED; +const xtreemfs_check_file_existsResponse_FILE_STATE xtreemfs_check_file_existsResponse_FILE_STATE_FILE_STATE_MAX = xtreemfs_check_file_existsResponse_FILE_STATE_ABANDONED; +const int xtreemfs_check_file_existsResponse_FILE_STATE_FILE_STATE_ARRAYSIZE = xtreemfs_check_file_existsResponse_FILE_STATE_FILE_STATE_MAX + 1; + +const ::google::protobuf::EnumDescriptor* xtreemfs_check_file_existsResponse_FILE_STATE_descriptor(); +inline const ::std::string& xtreemfs_check_file_existsResponse_FILE_STATE_Name(xtreemfs_check_file_existsResponse_FILE_STATE value) { + return ::google::protobuf::internal::NameOfEnum( + xtreemfs_check_file_existsResponse_FILE_STATE_descriptor(), value); +} +inline bool xtreemfs_check_file_existsResponse_FILE_STATE_Parse( + const ::std::string& name, xtreemfs_check_file_existsResponse_FILE_STATE* value) { + return ::google::protobuf::internal::ParseNamedEnum( + xtreemfs_check_file_existsResponse_FILE_STATE_descriptor(), name, value); +} +enum Setattrs { + SETATTR_MODE = 1, + SETATTR_UID = 2, + SETATTR_GID = 4, + SETATTR_SIZE = 8, + SETATTR_ATIME = 16, + SETATTR_MTIME = 32, + SETATTR_CTIME = 64, + SETATTR_ATTRIBUTES = 128 +}; +bool Setattrs_IsValid(int value); +const Setattrs Setattrs_MIN = SETATTR_MODE; +const Setattrs Setattrs_MAX = SETATTR_ATTRIBUTES; +const int Setattrs_ARRAYSIZE = Setattrs_MAX + 1; + +const ::google::protobuf::EnumDescriptor* Setattrs_descriptor(); +inline const ::std::string& Setattrs_Name(Setattrs value) { + return ::google::protobuf::internal::NameOfEnum( + Setattrs_descriptor(), value); +} +inline bool Setattrs_Parse( + const ::std::string& name, Setattrs* value) { + return ::google::protobuf::internal::ParseNamedEnum( + Setattrs_descriptor(), name, value); +} +enum XATTR_FLAGS { + XATTR_FLAGS_CREATE = 1, + XATTR_FLAGS_REPLACE = 2 +}; +bool XATTR_FLAGS_IsValid(int value); +const XATTR_FLAGS XATTR_FLAGS_MIN = XATTR_FLAGS_CREATE; +const XATTR_FLAGS XATTR_FLAGS_MAX = XATTR_FLAGS_REPLACE; +const int XATTR_FLAGS_ARRAYSIZE = XATTR_FLAGS_MAX + 1; + +const ::google::protobuf::EnumDescriptor* XATTR_FLAGS_descriptor(); +inline const ::std::string& XATTR_FLAGS_Name(XATTR_FLAGS value) { + return ::google::protobuf::internal::NameOfEnum( + XATTR_FLAGS_descriptor(), value); +} +inline bool XATTR_FLAGS_Parse( + const ::std::string& name, XATTR_FLAGS* value) { + return ::google::protobuf::internal::ParseNamedEnum( + XATTR_FLAGS_descriptor(), name, value); +} +enum ACCESS_FLAGS { + ACCESS_FLAGS_F_OK = 0, + ACCESS_FLAGS_X_OK = 1, + ACCESS_FLAGS_W_OK = 2, + ACCESS_FLAGS_R_OK = 4 +}; +bool ACCESS_FLAGS_IsValid(int value); +const ACCESS_FLAGS ACCESS_FLAGS_MIN = ACCESS_FLAGS_F_OK; +const ACCESS_FLAGS ACCESS_FLAGS_MAX = ACCESS_FLAGS_R_OK; +const int ACCESS_FLAGS_ARRAYSIZE = ACCESS_FLAGS_MAX + 1; + +const ::google::protobuf::EnumDescriptor* ACCESS_FLAGS_descriptor(); +inline const ::std::string& ACCESS_FLAGS_Name(ACCESS_FLAGS value) { + return ::google::protobuf::internal::NameOfEnum( + ACCESS_FLAGS_descriptor(), value); +} +inline bool ACCESS_FLAGS_Parse( + const ::std::string& name, ACCESS_FLAGS* value) { + return ::google::protobuf::internal::ParseNamedEnum( + ACCESS_FLAGS_descriptor(), name, value); +} +// =================================================================== + +class Stat : public ::google::protobuf::Message { + public: + Stat(); + virtual ~Stat(); + + Stat(const Stat& from); + + inline Stat& operator=(const Stat& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Stat& default_instance(); + + void Swap(Stat* other); + + // implements Message ---------------------------------------------- + + Stat* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Stat& from); + void MergeFrom(const Stat& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 dev = 1; + inline bool has_dev() const; + inline void clear_dev(); + static const int kDevFieldNumber = 1; + inline ::google::protobuf::uint64 dev() const; + inline void set_dev(::google::protobuf::uint64 value); + + // required fixed64 ino = 2; + inline bool has_ino() const; + inline void clear_ino(); + static const int kInoFieldNumber = 2; + inline ::google::protobuf::uint64 ino() const; + inline void set_ino(::google::protobuf::uint64 value); + + // required fixed32 mode = 3; + inline bool has_mode() const; + inline void clear_mode(); + static const int kModeFieldNumber = 3; + inline ::google::protobuf::uint32 mode() const; + inline void set_mode(::google::protobuf::uint32 value); + + // required fixed32 nlink = 4; + inline bool has_nlink() const; + inline void clear_nlink(); + static const int kNlinkFieldNumber = 4; + inline ::google::protobuf::uint32 nlink() const; + inline void set_nlink(::google::protobuf::uint32 value); + + // required string user_id = 5; + inline bool has_user_id() const; + inline void clear_user_id(); + static const int kUserIdFieldNumber = 5; + inline const ::std::string& user_id() const; + inline void set_user_id(const ::std::string& value); + inline void set_user_id(const char* value); + inline void set_user_id(const char* value, size_t size); + inline ::std::string* mutable_user_id(); + inline ::std::string* release_user_id(); + inline void set_allocated_user_id(::std::string* user_id); + + // required string group_id = 6; + inline bool has_group_id() const; + inline void clear_group_id(); + static const int kGroupIdFieldNumber = 6; + inline const ::std::string& group_id() const; + inline void set_group_id(const ::std::string& value); + inline void set_group_id(const char* value); + inline void set_group_id(const char* value, size_t size); + inline ::std::string* mutable_group_id(); + inline ::std::string* release_group_id(); + inline void set_allocated_group_id(::std::string* group_id); + + // required fixed64 size = 7; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 7; + inline ::google::protobuf::uint64 size() const; + inline void set_size(::google::protobuf::uint64 value); + + // required fixed64 atime_ns = 8; + inline bool has_atime_ns() const; + inline void clear_atime_ns(); + static const int kAtimeNsFieldNumber = 8; + inline ::google::protobuf::uint64 atime_ns() const; + inline void set_atime_ns(::google::protobuf::uint64 value); + + // required fixed64 mtime_ns = 9; + inline bool has_mtime_ns() const; + inline void clear_mtime_ns(); + static const int kMtimeNsFieldNumber = 9; + inline ::google::protobuf::uint64 mtime_ns() const; + inline void set_mtime_ns(::google::protobuf::uint64 value); + + // required fixed64 ctime_ns = 10; + inline bool has_ctime_ns() const; + inline void clear_ctime_ns(); + static const int kCtimeNsFieldNumber = 10; + inline ::google::protobuf::uint64 ctime_ns() const; + inline void set_ctime_ns(::google::protobuf::uint64 value); + + // required fixed32 blksize = 11; + inline bool has_blksize() const; + inline void clear_blksize(); + static const int kBlksizeFieldNumber = 11; + inline ::google::protobuf::uint32 blksize() const; + inline void set_blksize(::google::protobuf::uint32 value); + + // optional fixed64 etag = 12; + inline bool has_etag() const; + inline void clear_etag(); + static const int kEtagFieldNumber = 12; + inline ::google::protobuf::uint64 etag() const; + inline void set_etag(::google::protobuf::uint64 value); + + // required fixed32 truncate_epoch = 13; + inline bool has_truncate_epoch() const; + inline void clear_truncate_epoch(); + static const int kTruncateEpochFieldNumber = 13; + inline ::google::protobuf::uint32 truncate_epoch() const; + inline void set_truncate_epoch(::google::protobuf::uint32 value); + + // optional fixed32 attributes = 14; + inline bool has_attributes() const; + inline void clear_attributes(); + static const int kAttributesFieldNumber = 14; + inline ::google::protobuf::uint32 attributes() const; + inline void set_attributes(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Stat) + private: + inline void set_has_dev(); + inline void clear_has_dev(); + inline void set_has_ino(); + inline void clear_has_ino(); + inline void set_has_mode(); + inline void clear_has_mode(); + inline void set_has_nlink(); + inline void clear_has_nlink(); + inline void set_has_user_id(); + inline void clear_has_user_id(); + inline void set_has_group_id(); + inline void clear_has_group_id(); + inline void set_has_size(); + inline void clear_has_size(); + inline void set_has_atime_ns(); + inline void clear_has_atime_ns(); + inline void set_has_mtime_ns(); + inline void clear_has_mtime_ns(); + inline void set_has_ctime_ns(); + inline void clear_has_ctime_ns(); + inline void set_has_blksize(); + inline void clear_has_blksize(); + inline void set_has_etag(); + inline void clear_has_etag(); + inline void set_has_truncate_epoch(); + inline void clear_has_truncate_epoch(); + inline void set_has_attributes(); + inline void clear_has_attributes(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 dev_; + ::google::protobuf::uint64 ino_; + ::google::protobuf::uint32 mode_; + ::google::protobuf::uint32 nlink_; + ::std::string* user_id_; + ::std::string* group_id_; + ::google::protobuf::uint64 size_; + ::google::protobuf::uint64 atime_ns_; + ::google::protobuf::uint64 mtime_ns_; + ::google::protobuf::uint64 ctime_ns_; + ::google::protobuf::uint64 etag_; + ::google::protobuf::uint32 blksize_; + ::google::protobuf::uint32 truncate_epoch_; + ::google::protobuf::uint32 attributes_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(14 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static Stat* default_instance_; +}; +// ------------------------------------------------------------------- + +class DirectoryEntry : public ::google::protobuf::Message { + public: + DirectoryEntry(); + virtual ~DirectoryEntry(); + + DirectoryEntry(const DirectoryEntry& from); + + inline DirectoryEntry& operator=(const DirectoryEntry& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DirectoryEntry& default_instance(); + + void Swap(DirectoryEntry* other); + + // implements Message ---------------------------------------------- + + DirectoryEntry* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DirectoryEntry& from); + void MergeFrom(const DirectoryEntry& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // optional .xtreemfs.pbrpc.Stat stbuf = 2; + inline bool has_stbuf() const; + inline void clear_stbuf(); + static const int kStbufFieldNumber = 2; + inline const ::xtreemfs::pbrpc::Stat& stbuf() const; + inline ::xtreemfs::pbrpc::Stat* mutable_stbuf(); + inline ::xtreemfs::pbrpc::Stat* release_stbuf(); + inline void set_allocated_stbuf(::xtreemfs::pbrpc::Stat* stbuf); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.DirectoryEntry) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_stbuf(); + inline void clear_has_stbuf(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* name_; + ::xtreemfs::pbrpc::Stat* stbuf_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static DirectoryEntry* default_instance_; +}; +// ------------------------------------------------------------------- + +class DirectoryEntries : public ::google::protobuf::Message { + public: + DirectoryEntries(); + virtual ~DirectoryEntries(); + + DirectoryEntries(const DirectoryEntries& from); + + inline DirectoryEntries& operator=(const DirectoryEntries& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const DirectoryEntries& default_instance(); + + void Swap(DirectoryEntries* other); + + // implements Message ---------------------------------------------- + + DirectoryEntries* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const DirectoryEntries& from); + void MergeFrom(const DirectoryEntries& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .xtreemfs.pbrpc.DirectoryEntry entries = 1; + inline int entries_size() const; + inline void clear_entries(); + static const int kEntriesFieldNumber = 1; + inline const ::xtreemfs::pbrpc::DirectoryEntry& entries(int index) const; + inline ::xtreemfs::pbrpc::DirectoryEntry* mutable_entries(int index); + inline ::xtreemfs::pbrpc::DirectoryEntry* add_entries(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::DirectoryEntry >& + entries() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::DirectoryEntry >* + mutable_entries(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.DirectoryEntries) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::DirectoryEntry > entries_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static DirectoryEntries* default_instance_; +}; +// ------------------------------------------------------------------- + +class XAttr : public ::google::protobuf::Message { + public: + XAttr(); + virtual ~XAttr(); + + XAttr(const XAttr& from); + + inline XAttr& operator=(const XAttr& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const XAttr& default_instance(); + + void Swap(XAttr* other); + + // implements Message ---------------------------------------------- + + XAttr* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const XAttr& from); + void MergeFrom(const XAttr& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // optional string value = 2; + inline bool has_value() const; + inline void clear_value(); + static const int kValueFieldNumber = 2; + inline const ::std::string& value() const; + inline void set_value(const ::std::string& value); + inline void set_value(const char* value); + inline void set_value(const char* value, size_t size); + inline ::std::string* mutable_value(); + inline ::std::string* release_value(); + inline void set_allocated_value(::std::string* value); + + // optional bytes value_bytes_string = 3; + inline bool has_value_bytes_string() const; + inline void clear_value_bytes_string(); + static const int kValueBytesStringFieldNumber = 3; + inline const ::std::string& value_bytes_string() const; + inline void set_value_bytes_string(const ::std::string& value); + inline void set_value_bytes_string(const char* value); + inline void set_value_bytes_string(const void* value, size_t size); + inline ::std::string* mutable_value_bytes_string(); + inline ::std::string* release_value_bytes_string(); + inline void set_allocated_value_bytes_string(::std::string* value_bytes_string); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.XAttr) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_value(); + inline void clear_has_value(); + inline void set_has_value_bytes_string(); + inline void clear_has_value_bytes_string(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* name_; + ::std::string* value_; + ::std::string* value_bytes_string_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static XAttr* default_instance_; +}; +// ------------------------------------------------------------------- + +class Volume : public ::google::protobuf::Message { + public: + Volume(); + virtual ~Volume(); + + Volume(const Volume& from); + + inline Volume& operator=(const Volume& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Volume& default_instance(); + + void Swap(Volume* other); + + // implements Message ---------------------------------------------- + + Volume* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Volume& from); + void MergeFrom(const Volume& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1; + inline bool has_access_control_policy() const; + inline void clear_access_control_policy(); + static const int kAccessControlPolicyFieldNumber = 1; + inline ::xtreemfs::pbrpc::AccessControlPolicyType access_control_policy() const; + inline void set_access_control_policy(::xtreemfs::pbrpc::AccessControlPolicyType value); + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 2; + inline bool has_default_striping_policy() const; + inline void clear_default_striping_policy(); + static const int kDefaultStripingPolicyFieldNumber = 2; + inline const ::xtreemfs::pbrpc::StripingPolicy& default_striping_policy() const; + inline ::xtreemfs::pbrpc::StripingPolicy* mutable_default_striping_policy(); + inline ::xtreemfs::pbrpc::StripingPolicy* release_default_striping_policy(); + inline void set_allocated_default_striping_policy(::xtreemfs::pbrpc::StripingPolicy* default_striping_policy); + + // required string id = 3; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 3; + inline const ::std::string& id() const; + inline void set_id(const ::std::string& value); + inline void set_id(const char* value); + inline void set_id(const char* value, size_t size); + inline ::std::string* mutable_id(); + inline ::std::string* release_id(); + inline void set_allocated_id(::std::string* id); + + // required fixed32 mode = 4; + inline bool has_mode() const; + inline void clear_mode(); + static const int kModeFieldNumber = 4; + inline ::google::protobuf::uint32 mode() const; + inline void set_mode(::google::protobuf::uint32 value); + + // required string name = 5; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 5; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // required string owner_group_id = 6; + inline bool has_owner_group_id() const; + inline void clear_owner_group_id(); + static const int kOwnerGroupIdFieldNumber = 6; + inline const ::std::string& owner_group_id() const; + inline void set_owner_group_id(const ::std::string& value); + inline void set_owner_group_id(const char* value); + inline void set_owner_group_id(const char* value, size_t size); + inline ::std::string* mutable_owner_group_id(); + inline ::std::string* release_owner_group_id(); + inline void set_allocated_owner_group_id(::std::string* owner_group_id); + + // required string owner_user_id = 7; + inline bool has_owner_user_id() const; + inline void clear_owner_user_id(); + static const int kOwnerUserIdFieldNumber = 7; + inline const ::std::string& owner_user_id() const; + inline void set_owner_user_id(const ::std::string& value); + inline void set_owner_user_id(const char* value); + inline void set_owner_user_id(const char* value, size_t size); + inline ::std::string* mutable_owner_user_id(); + inline ::std::string* release_owner_user_id(); + inline void set_allocated_owner_user_id(::std::string* owner_user_id); + + // repeated .xtreemfs.pbrpc.KeyValuePair attrs = 8; + inline int attrs_size() const; + inline void clear_attrs(); + static const int kAttrsFieldNumber = 8; + inline const ::xtreemfs::pbrpc::KeyValuePair& attrs(int index) const; + inline ::xtreemfs::pbrpc::KeyValuePair* mutable_attrs(int index); + inline ::xtreemfs::pbrpc::KeyValuePair* add_attrs(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >& + attrs() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >* + mutable_attrs(); + + // optional fixed64 quota = 9; + inline bool has_quota() const; + inline void clear_quota(); + static const int kQuotaFieldNumber = 9; + inline ::google::protobuf::uint64 quota() const; + inline void set_quota(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Volume) + private: + inline void set_has_access_control_policy(); + inline void clear_has_access_control_policy(); + inline void set_has_default_striping_policy(); + inline void clear_has_default_striping_policy(); + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_mode(); + inline void clear_has_mode(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_owner_group_id(); + inline void clear_has_owner_group_id(); + inline void set_has_owner_user_id(); + inline void clear_has_owner_user_id(); + inline void set_has_quota(); + inline void clear_has_quota(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::StripingPolicy* default_striping_policy_; + int access_control_policy_; + ::google::protobuf::uint32 mode_; + ::std::string* id_; + ::std::string* name_; + ::std::string* owner_group_id_; + ::std::string* owner_user_id_; + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair > attrs_; + ::google::protobuf::uint64 quota_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static Volume* default_instance_; +}; +// ------------------------------------------------------------------- + +class Volumes : public ::google::protobuf::Message { + public: + Volumes(); + virtual ~Volumes(); + + Volumes(const Volumes& from); + + inline Volumes& operator=(const Volumes& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Volumes& default_instance(); + + void Swap(Volumes* other); + + // implements Message ---------------------------------------------- + + Volumes* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Volumes& from); + void MergeFrom(const Volumes& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .xtreemfs.pbrpc.Volume volumes = 1; + inline int volumes_size() const; + inline void clear_volumes(); + static const int kVolumesFieldNumber = 1; + inline const ::xtreemfs::pbrpc::Volume& volumes(int index) const; + inline ::xtreemfs::pbrpc::Volume* mutable_volumes(int index); + inline ::xtreemfs::pbrpc::Volume* add_volumes(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Volume >& + volumes() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Volume >* + mutable_volumes(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Volumes) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Volume > volumes_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static Volumes* default_instance_; +}; +// ------------------------------------------------------------------- + +class StatVFS : public ::google::protobuf::Message { + public: + StatVFS(); + virtual ~StatVFS(); + + StatVFS(const StatVFS& from); + + inline StatVFS& operator=(const StatVFS& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const StatVFS& default_instance(); + + void Swap(StatVFS* other); + + // implements Message ---------------------------------------------- + + StatVFS* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const StatVFS& from); + void MergeFrom(const StatVFS& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 bsize = 1; + inline bool has_bsize() const; + inline void clear_bsize(); + static const int kBsizeFieldNumber = 1; + inline ::google::protobuf::uint32 bsize() const; + inline void set_bsize(::google::protobuf::uint32 value); + + // required fixed64 bavail = 2; + inline bool has_bavail() const; + inline void clear_bavail(); + static const int kBavailFieldNumber = 2; + inline ::google::protobuf::uint64 bavail() const; + inline void set_bavail(::google::protobuf::uint64 value); + + // optional fixed64 bfree = 13; + inline bool has_bfree() const; + inline void clear_bfree(); + static const int kBfreeFieldNumber = 13; + inline ::google::protobuf::uint64 bfree() const; + inline void set_bfree(::google::protobuf::uint64 value); + + // required fixed64 blocks = 3; + inline bool has_blocks() const; + inline void clear_blocks(); + static const int kBlocksFieldNumber = 3; + inline ::google::protobuf::uint64 blocks() const; + inline void set_blocks(::google::protobuf::uint64 value); + + // required string fsid = 4; + inline bool has_fsid() const; + inline void clear_fsid(); + static const int kFsidFieldNumber = 4; + inline const ::std::string& fsid() const; + inline void set_fsid(const ::std::string& value); + inline void set_fsid(const char* value); + inline void set_fsid(const char* value, size_t size); + inline ::std::string* mutable_fsid(); + inline ::std::string* release_fsid(); + inline void set_allocated_fsid(::std::string* fsid); + + // required fixed32 namemax = 5; + inline bool has_namemax() const; + inline void clear_namemax(); + static const int kNamemaxFieldNumber = 5; + inline ::google::protobuf::uint32 namemax() const; + inline void set_namemax(::google::protobuf::uint32 value); + + // required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6; + inline bool has_access_control_policy() const; + inline void clear_access_control_policy(); + static const int kAccessControlPolicyFieldNumber = 6; + inline ::xtreemfs::pbrpc::AccessControlPolicyType access_control_policy() const; + inline void set_access_control_policy(::xtreemfs::pbrpc::AccessControlPolicyType value); + + // required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 7; + inline bool has_default_striping_policy() const; + inline void clear_default_striping_policy(); + static const int kDefaultStripingPolicyFieldNumber = 7; + inline const ::xtreemfs::pbrpc::StripingPolicy& default_striping_policy() const; + inline ::xtreemfs::pbrpc::StripingPolicy* mutable_default_striping_policy(); + inline ::xtreemfs::pbrpc::StripingPolicy* release_default_striping_policy(); + inline void set_allocated_default_striping_policy(::xtreemfs::pbrpc::StripingPolicy* default_striping_policy); + + // required fixed64 etag = 8; + inline bool has_etag() const; + inline void clear_etag(); + static const int kEtagFieldNumber = 8; + inline ::google::protobuf::uint64 etag() const; + inline void set_etag(::google::protobuf::uint64 value); + + // required fixed32 mode = 9; + inline bool has_mode() const; + inline void clear_mode(); + static const int kModeFieldNumber = 9; + inline ::google::protobuf::uint32 mode() const; + inline void set_mode(::google::protobuf::uint32 value); + + // required string name = 10; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 10; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // required string owner_group_id = 11; + inline bool has_owner_group_id() const; + inline void clear_owner_group_id(); + static const int kOwnerGroupIdFieldNumber = 11; + inline const ::std::string& owner_group_id() const; + inline void set_owner_group_id(const ::std::string& value); + inline void set_owner_group_id(const char* value); + inline void set_owner_group_id(const char* value, size_t size); + inline ::std::string* mutable_owner_group_id(); + inline ::std::string* release_owner_group_id(); + inline void set_allocated_owner_group_id(::std::string* owner_group_id); + + // required string owner_user_id = 12; + inline bool has_owner_user_id() const; + inline void clear_owner_user_id(); + static const int kOwnerUserIdFieldNumber = 12; + inline const ::std::string& owner_user_id() const; + inline void set_owner_user_id(const ::std::string& value); + inline void set_owner_user_id(const char* value); + inline void set_owner_user_id(const char* value, size_t size); + inline ::std::string* mutable_owner_user_id(); + inline ::std::string* release_owner_user_id(); + inline void set_allocated_owner_user_id(::std::string* owner_user_id); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.StatVFS) + private: + inline void set_has_bsize(); + inline void clear_has_bsize(); + inline void set_has_bavail(); + inline void clear_has_bavail(); + inline void set_has_bfree(); + inline void clear_has_bfree(); + inline void set_has_blocks(); + inline void clear_has_blocks(); + inline void set_has_fsid(); + inline void clear_has_fsid(); + inline void set_has_namemax(); + inline void clear_has_namemax(); + inline void set_has_access_control_policy(); + inline void clear_has_access_control_policy(); + inline void set_has_default_striping_policy(); + inline void clear_has_default_striping_policy(); + inline void set_has_etag(); + inline void clear_has_etag(); + inline void set_has_mode(); + inline void clear_has_mode(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_owner_group_id(); + inline void clear_has_owner_group_id(); + inline void set_has_owner_user_id(); + inline void clear_has_owner_user_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 bavail_; + ::google::protobuf::uint64 bfree_; + ::google::protobuf::uint32 bsize_; + ::google::protobuf::uint32 namemax_; + ::google::protobuf::uint64 blocks_; + ::std::string* fsid_; + ::xtreemfs::pbrpc::StripingPolicy* default_striping_policy_; + int access_control_policy_; + ::google::protobuf::uint32 mode_; + ::google::protobuf::uint64 etag_; + ::std::string* name_; + ::std::string* owner_group_id_; + ::std::string* owner_user_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(13 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static StatVFS* default_instance_; +}; +// ------------------------------------------------------------------- + +class fsetattrRequest : public ::google::protobuf::Message { + public: + fsetattrRequest(); + virtual ~fsetattrRequest(); + + fsetattrRequest(const fsetattrRequest& from); + + inline fsetattrRequest& operator=(const fsetattrRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const fsetattrRequest& default_instance(); + + void Swap(fsetattrRequest* other); + + // implements Message ---------------------------------------------- + + fsetattrRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const fsetattrRequest& from); + void MergeFrom(const fsetattrRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.Stat stbuf = 1; + inline bool has_stbuf() const; + inline void clear_stbuf(); + static const int kStbufFieldNumber = 1; + inline const ::xtreemfs::pbrpc::Stat& stbuf() const; + inline ::xtreemfs::pbrpc::Stat* mutable_stbuf(); + inline ::xtreemfs::pbrpc::Stat* release_stbuf(); + inline void set_allocated_stbuf(::xtreemfs::pbrpc::Stat* stbuf); + + // required fixed32 to_set = 2; + inline bool has_to_set() const; + inline void clear_to_set(); + static const int kToSetFieldNumber = 2; + inline ::google::protobuf::uint32 to_set() const; + inline void set_to_set(::google::protobuf::uint32 value); + + // required .xtreemfs.pbrpc.XCap cap = 3; + inline bool has_cap() const; + inline void clear_cap(); + static const int kCapFieldNumber = 3; + inline const ::xtreemfs::pbrpc::XCap& cap() const; + inline ::xtreemfs::pbrpc::XCap* mutable_cap(); + inline ::xtreemfs::pbrpc::XCap* release_cap(); + inline void set_allocated_cap(::xtreemfs::pbrpc::XCap* cap); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.fsetattrRequest) + private: + inline void set_has_stbuf(); + inline void clear_has_stbuf(); + inline void set_has_to_set(); + inline void clear_has_to_set(); + inline void set_has_cap(); + inline void clear_has_cap(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::Stat* stbuf_; + ::xtreemfs::pbrpc::XCap* cap_; + ::google::protobuf::uint32 to_set_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static fsetattrRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class getattrRequest : public ::google::protobuf::Message { + public: + getattrRequest(); + virtual ~getattrRequest(); + + getattrRequest(const getattrRequest& from); + + inline getattrRequest& operator=(const getattrRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const getattrRequest& default_instance(); + + void Swap(getattrRequest* other); + + // implements Message ---------------------------------------------- + + getattrRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const getattrRequest& from); + void MergeFrom(const getattrRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required fixed64 known_etag = 3; + inline bool has_known_etag() const; + inline void clear_known_etag(); + static const int kKnownEtagFieldNumber = 3; + inline ::google::protobuf::uint64 known_etag() const; + inline void set_known_etag(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.getattrRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_known_etag(); + inline void clear_has_known_etag(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::google::protobuf::uint64 known_etag_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static getattrRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class getattrResponse : public ::google::protobuf::Message { + public: + getattrResponse(); + virtual ~getattrResponse(); + + getattrResponse(const getattrResponse& from); + + inline getattrResponse& operator=(const getattrResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const getattrResponse& default_instance(); + + void Swap(getattrResponse* other); + + // implements Message ---------------------------------------------- + + getattrResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const getattrResponse& from); + void MergeFrom(const getattrResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .xtreemfs.pbrpc.Stat stbuf = 1; + inline bool has_stbuf() const; + inline void clear_stbuf(); + static const int kStbufFieldNumber = 1; + inline const ::xtreemfs::pbrpc::Stat& stbuf() const; + inline ::xtreemfs::pbrpc::Stat* mutable_stbuf(); + inline ::xtreemfs::pbrpc::Stat* release_stbuf(); + inline void set_allocated_stbuf(::xtreemfs::pbrpc::Stat* stbuf); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.getattrResponse) + private: + inline void set_has_stbuf(); + inline void clear_has_stbuf(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::Stat* stbuf_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static getattrResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class getxattrRequest : public ::google::protobuf::Message { + public: + getxattrRequest(); + virtual ~getxattrRequest(); + + getxattrRequest(const getxattrRequest& from); + + inline getxattrRequest& operator=(const getxattrRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const getxattrRequest& default_instance(); + + void Swap(getxattrRequest* other); + + // implements Message ---------------------------------------------- + + getxattrRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const getxattrRequest& from); + void MergeFrom(const getxattrRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.getxattrRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_name(); + inline void clear_has_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::std::string* name_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static getxattrRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class getxattrResponse : public ::google::protobuf::Message { + public: + getxattrResponse(); + virtual ~getxattrResponse(); + + getxattrResponse(const getxattrResponse& from); + + inline getxattrResponse& operator=(const getxattrResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const getxattrResponse& default_instance(); + + void Swap(getxattrResponse* other); + + // implements Message ---------------------------------------------- + + getxattrResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const getxattrResponse& from); + void MergeFrom(const getxattrResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string value = 1; + inline bool has_value() const; + inline void clear_value(); + static const int kValueFieldNumber = 1; + inline const ::std::string& value() const; + inline void set_value(const ::std::string& value); + inline void set_value(const char* value); + inline void set_value(const char* value, size_t size); + inline ::std::string* mutable_value(); + inline ::std::string* release_value(); + inline void set_allocated_value(::std::string* value); + + // optional bytes value_bytes_string = 2; + inline bool has_value_bytes_string() const; + inline void clear_value_bytes_string(); + static const int kValueBytesStringFieldNumber = 2; + inline const ::std::string& value_bytes_string() const; + inline void set_value_bytes_string(const ::std::string& value); + inline void set_value_bytes_string(const char* value); + inline void set_value_bytes_string(const void* value, size_t size); + inline ::std::string* mutable_value_bytes_string(); + inline ::std::string* release_value_bytes_string(); + inline void set_allocated_value_bytes_string(::std::string* value_bytes_string); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.getxattrResponse) + private: + inline void set_has_value(); + inline void clear_has_value(); + inline void set_has_value_bytes_string(); + inline void clear_has_value_bytes_string(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* value_; + ::std::string* value_bytes_string_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static getxattrResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class linkRequest : public ::google::protobuf::Message { + public: + linkRequest(); + virtual ~linkRequest(); + + linkRequest(const linkRequest& from); + + inline linkRequest& operator=(const linkRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const linkRequest& default_instance(); + + void Swap(linkRequest* other); + + // implements Message ---------------------------------------------- + + linkRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const linkRequest& from); + void MergeFrom(const linkRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string target_path = 2; + inline bool has_target_path() const; + inline void clear_target_path(); + static const int kTargetPathFieldNumber = 2; + inline const ::std::string& target_path() const; + inline void set_target_path(const ::std::string& value); + inline void set_target_path(const char* value); + inline void set_target_path(const char* value, size_t size); + inline ::std::string* mutable_target_path(); + inline ::std::string* release_target_path(); + inline void set_allocated_target_path(::std::string* target_path); + + // required string link_path = 3; + inline bool has_link_path() const; + inline void clear_link_path(); + static const int kLinkPathFieldNumber = 3; + inline const ::std::string& link_path() const; + inline void set_link_path(const ::std::string& value); + inline void set_link_path(const char* value); + inline void set_link_path(const char* value, size_t size); + inline ::std::string* mutable_link_path(); + inline ::std::string* release_link_path(); + inline void set_allocated_link_path(::std::string* link_path); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.linkRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_target_path(); + inline void clear_has_target_path(); + inline void set_has_link_path(); + inline void clear_has_link_path(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* target_path_; + ::std::string* link_path_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static linkRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class listxattrRequest : public ::google::protobuf::Message { + public: + listxattrRequest(); + virtual ~listxattrRequest(); + + listxattrRequest(const listxattrRequest& from); + + inline listxattrRequest& operator=(const listxattrRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const listxattrRequest& default_instance(); + + void Swap(listxattrRequest* other); + + // implements Message ---------------------------------------------- + + listxattrRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const listxattrRequest& from); + void MergeFrom(const listxattrRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required bool names_only = 3; + inline bool has_names_only() const; + inline void clear_names_only(); + static const int kNamesOnlyFieldNumber = 3; + inline bool names_only() const; + inline void set_names_only(bool value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.listxattrRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_names_only(); + inline void clear_has_names_only(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + bool names_only_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static listxattrRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class listxattrResponse : public ::google::protobuf::Message { + public: + listxattrResponse(); + virtual ~listxattrResponse(); + + listxattrResponse(const listxattrResponse& from); + + inline listxattrResponse& operator=(const listxattrResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const listxattrResponse& default_instance(); + + void Swap(listxattrResponse* other); + + // implements Message ---------------------------------------------- + + listxattrResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const listxattrResponse& from); + void MergeFrom(const listxattrResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .xtreemfs.pbrpc.XAttr xattrs = 1; + inline int xattrs_size() const; + inline void clear_xattrs(); + static const int kXattrsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::XAttr& xattrs(int index) const; + inline ::xtreemfs::pbrpc::XAttr* mutable_xattrs(int index); + inline ::xtreemfs::pbrpc::XAttr* add_xattrs(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::XAttr >& + xattrs() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::XAttr >* + mutable_xattrs(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.listxattrResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::XAttr > xattrs_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static listxattrResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class mkdirRequest : public ::google::protobuf::Message { + public: + mkdirRequest(); + virtual ~mkdirRequest(); + + mkdirRequest(const mkdirRequest& from); + + inline mkdirRequest& operator=(const mkdirRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const mkdirRequest& default_instance(); + + void Swap(mkdirRequest* other); + + // implements Message ---------------------------------------------- + + mkdirRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const mkdirRequest& from); + void MergeFrom(const mkdirRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required fixed32 mode = 3; + inline bool has_mode() const; + inline void clear_mode(); + static const int kModeFieldNumber = 3; + inline ::google::protobuf::uint32 mode() const; + inline void set_mode(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.mkdirRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_mode(); + inline void clear_has_mode(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::google::protobuf::uint32 mode_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static mkdirRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class openRequest : public ::google::protobuf::Message { + public: + openRequest(); + virtual ~openRequest(); + + openRequest(const openRequest& from); + + inline openRequest& operator=(const openRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const openRequest& default_instance(); + + void Swap(openRequest* other); + + // implements Message ---------------------------------------------- + + openRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const openRequest& from); + void MergeFrom(const openRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required fixed32 flags = 3; + inline bool has_flags() const; + inline void clear_flags(); + static const int kFlagsFieldNumber = 3; + inline ::google::protobuf::uint32 flags() const; + inline void set_flags(::google::protobuf::uint32 value); + + // required fixed32 mode = 4; + inline bool has_mode() const; + inline void clear_mode(); + static const int kModeFieldNumber = 4; + inline ::google::protobuf::uint32 mode() const; + inline void set_mode(::google::protobuf::uint32 value); + + // required fixed32 attributes = 5; + inline bool has_attributes() const; + inline void clear_attributes(); + static const int kAttributesFieldNumber = 5; + inline ::google::protobuf::uint32 attributes() const; + inline void set_attributes(::google::protobuf::uint32 value); + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6; + inline bool has_coordinates() const; + inline void clear_coordinates(); + static const int kCoordinatesFieldNumber = 6; + inline const ::xtreemfs::pbrpc::VivaldiCoordinates& coordinates() const; + inline ::xtreemfs::pbrpc::VivaldiCoordinates* mutable_coordinates(); + inline ::xtreemfs::pbrpc::VivaldiCoordinates* release_coordinates(); + inline void set_allocated_coordinates(::xtreemfs::pbrpc::VivaldiCoordinates* coordinates); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.openRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_flags(); + inline void clear_has_flags(); + inline void set_has_mode(); + inline void clear_has_mode(); + inline void set_has_attributes(); + inline void clear_has_attributes(); + inline void set_has_coordinates(); + inline void clear_has_coordinates(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::google::protobuf::uint32 flags_; + ::google::protobuf::uint32 mode_; + ::xtreemfs::pbrpc::VivaldiCoordinates* coordinates_; + ::google::protobuf::uint32 attributes_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static openRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class openResponse : public ::google::protobuf::Message { + public: + openResponse(); + virtual ~openResponse(); + + openResponse(const openResponse& from); + + inline openResponse& operator=(const openResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const openResponse& default_instance(); + + void Swap(openResponse* other); + + // implements Message ---------------------------------------------- + + openResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const openResponse& from); + void MergeFrom(const openResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials creds = 1; + inline bool has_creds() const; + inline void clear_creds(); + static const int kCredsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& creds() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_creds(); + inline ::xtreemfs::pbrpc::FileCredentials* release_creds(); + inline void set_allocated_creds(::xtreemfs::pbrpc::FileCredentials* creds); + + // required fixed32 timestamp_s = 2; + inline bool has_timestamp_s() const; + inline void clear_timestamp_s(); + static const int kTimestampSFieldNumber = 2; + inline ::google::protobuf::uint32 timestamp_s() const; + inline void set_timestamp_s(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.openResponse) + private: + inline void set_has_creds(); + inline void clear_has_creds(); + inline void set_has_timestamp_s(); + inline void clear_has_timestamp_s(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* creds_; + ::google::protobuf::uint32 timestamp_s_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static openResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class readdirRequest : public ::google::protobuf::Message { + public: + readdirRequest(); + virtual ~readdirRequest(); + + readdirRequest(const readdirRequest& from); + + inline readdirRequest& operator=(const readdirRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const readdirRequest& default_instance(); + + void Swap(readdirRequest* other); + + // implements Message ---------------------------------------------- + + readdirRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const readdirRequest& from); + void MergeFrom(const readdirRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required fixed64 known_etag = 3; + inline bool has_known_etag() const; + inline void clear_known_etag(); + static const int kKnownEtagFieldNumber = 3; + inline ::google::protobuf::uint64 known_etag() const; + inline void set_known_etag(::google::protobuf::uint64 value); + + // required fixed32 limit_directory_entries_count = 4; + inline bool has_limit_directory_entries_count() const; + inline void clear_limit_directory_entries_count(); + static const int kLimitDirectoryEntriesCountFieldNumber = 4; + inline ::google::protobuf::uint32 limit_directory_entries_count() const; + inline void set_limit_directory_entries_count(::google::protobuf::uint32 value); + + // required bool names_only = 5; + inline bool has_names_only() const; + inline void clear_names_only(); + static const int kNamesOnlyFieldNumber = 5; + inline bool names_only() const; + inline void set_names_only(bool value); + + // required fixed64 seen_directory_entries_count = 6; + inline bool has_seen_directory_entries_count() const; + inline void clear_seen_directory_entries_count(); + static const int kSeenDirectoryEntriesCountFieldNumber = 6; + inline ::google::protobuf::uint64 seen_directory_entries_count() const; + inline void set_seen_directory_entries_count(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.readdirRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_known_etag(); + inline void clear_has_known_etag(); + inline void set_has_limit_directory_entries_count(); + inline void clear_has_limit_directory_entries_count(); + inline void set_has_names_only(); + inline void clear_has_names_only(); + inline void set_has_seen_directory_entries_count(); + inline void clear_has_seen_directory_entries_count(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::google::protobuf::uint64 known_etag_; + ::google::protobuf::uint32 limit_directory_entries_count_; + bool names_only_; + ::google::protobuf::uint64 seen_directory_entries_count_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static readdirRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class readlinkRequest : public ::google::protobuf::Message { + public: + readlinkRequest(); + virtual ~readlinkRequest(); + + readlinkRequest(const readlinkRequest& from); + + inline readlinkRequest& operator=(const readlinkRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const readlinkRequest& default_instance(); + + void Swap(readlinkRequest* other); + + // implements Message ---------------------------------------------- + + readlinkRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const readlinkRequest& from); + void MergeFrom(const readlinkRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.readlinkRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static readlinkRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class readlinkResponse : public ::google::protobuf::Message { + public: + readlinkResponse(); + virtual ~readlinkResponse(); + + readlinkResponse(const readlinkResponse& from); + + inline readlinkResponse& operator=(const readlinkResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const readlinkResponse& default_instance(); + + void Swap(readlinkResponse* other); + + // implements Message ---------------------------------------------- + + readlinkResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const readlinkResponse& from); + void MergeFrom(const readlinkResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated string link_target_path = 1; + inline int link_target_path_size() const; + inline void clear_link_target_path(); + static const int kLinkTargetPathFieldNumber = 1; + inline const ::std::string& link_target_path(int index) const; + inline ::std::string* mutable_link_target_path(int index); + inline void set_link_target_path(int index, const ::std::string& value); + inline void set_link_target_path(int index, const char* value); + inline void set_link_target_path(int index, const char* value, size_t size); + inline ::std::string* add_link_target_path(); + inline void add_link_target_path(const ::std::string& value); + inline void add_link_target_path(const char* value); + inline void add_link_target_path(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& link_target_path() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_link_target_path(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.readlinkResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::std::string> link_target_path_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static readlinkResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class removexattrRequest : public ::google::protobuf::Message { + public: + removexattrRequest(); + virtual ~removexattrRequest(); + + removexattrRequest(const removexattrRequest& from); + + inline removexattrRequest& operator=(const removexattrRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const removexattrRequest& default_instance(); + + void Swap(removexattrRequest* other); + + // implements Message ---------------------------------------------- + + removexattrRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const removexattrRequest& from); + void MergeFrom(const removexattrRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.removexattrRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_name(); + inline void clear_has_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::std::string* name_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static removexattrRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class renameRequest : public ::google::protobuf::Message { + public: + renameRequest(); + virtual ~renameRequest(); + + renameRequest(const renameRequest& from); + + inline renameRequest& operator=(const renameRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const renameRequest& default_instance(); + + void Swap(renameRequest* other); + + // implements Message ---------------------------------------------- + + renameRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const renameRequest& from); + void MergeFrom(const renameRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string source_path = 2; + inline bool has_source_path() const; + inline void clear_source_path(); + static const int kSourcePathFieldNumber = 2; + inline const ::std::string& source_path() const; + inline void set_source_path(const ::std::string& value); + inline void set_source_path(const char* value); + inline void set_source_path(const char* value, size_t size); + inline ::std::string* mutable_source_path(); + inline ::std::string* release_source_path(); + inline void set_allocated_source_path(::std::string* source_path); + + // required string target_path = 3; + inline bool has_target_path() const; + inline void clear_target_path(); + static const int kTargetPathFieldNumber = 3; + inline const ::std::string& target_path() const; + inline void set_target_path(const ::std::string& value); + inline void set_target_path(const char* value); + inline void set_target_path(const char* value, size_t size); + inline ::std::string* mutable_target_path(); + inline ::std::string* release_target_path(); + inline void set_allocated_target_path(::std::string* target_path); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.renameRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_source_path(); + inline void clear_has_source_path(); + inline void set_has_target_path(); + inline void clear_has_target_path(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* source_path_; + ::std::string* target_path_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static renameRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class renameResponse : public ::google::protobuf::Message { + public: + renameResponse(); + virtual ~renameResponse(); + + renameResponse(const renameResponse& from); + + inline renameResponse& operator=(const renameResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const renameResponse& default_instance(); + + void Swap(renameResponse* other); + + // implements Message ---------------------------------------------- + + renameResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const renameResponse& from); + void MergeFrom(const renameResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 timestamp_s = 1; + inline bool has_timestamp_s() const; + inline void clear_timestamp_s(); + static const int kTimestampSFieldNumber = 1; + inline ::google::protobuf::uint32 timestamp_s() const; + inline void set_timestamp_s(::google::protobuf::uint32 value); + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + inline bool has_creds() const; + inline void clear_creds(); + static const int kCredsFieldNumber = 2; + inline const ::xtreemfs::pbrpc::FileCredentials& creds() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_creds(); + inline ::xtreemfs::pbrpc::FileCredentials* release_creds(); + inline void set_allocated_creds(::xtreemfs::pbrpc::FileCredentials* creds); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.renameResponse) + private: + inline void set_has_timestamp_s(); + inline void clear_has_timestamp_s(); + inline void set_has_creds(); + inline void clear_has_creds(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* creds_; + ::google::protobuf::uint32 timestamp_s_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static renameResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class rmdirRequest : public ::google::protobuf::Message { + public: + rmdirRequest(); + virtual ~rmdirRequest(); + + rmdirRequest(const rmdirRequest& from); + + inline rmdirRequest& operator=(const rmdirRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const rmdirRequest& default_instance(); + + void Swap(rmdirRequest* other); + + // implements Message ---------------------------------------------- + + rmdirRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const rmdirRequest& from); + void MergeFrom(const rmdirRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.rmdirRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static rmdirRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class setattrRequest : public ::google::protobuf::Message { + public: + setattrRequest(); + virtual ~setattrRequest(); + + setattrRequest(const setattrRequest& from); + + inline setattrRequest& operator=(const setattrRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const setattrRequest& default_instance(); + + void Swap(setattrRequest* other); + + // implements Message ---------------------------------------------- + + setattrRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const setattrRequest& from); + void MergeFrom(const setattrRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required .xtreemfs.pbrpc.Stat stbuf = 3; + inline bool has_stbuf() const; + inline void clear_stbuf(); + static const int kStbufFieldNumber = 3; + inline const ::xtreemfs::pbrpc::Stat& stbuf() const; + inline ::xtreemfs::pbrpc::Stat* mutable_stbuf(); + inline ::xtreemfs::pbrpc::Stat* release_stbuf(); + inline void set_allocated_stbuf(::xtreemfs::pbrpc::Stat* stbuf); + + // required fixed32 to_set = 4; + inline bool has_to_set() const; + inline void clear_to_set(); + static const int kToSetFieldNumber = 4; + inline ::google::protobuf::uint32 to_set() const; + inline void set_to_set(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.setattrRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_stbuf(); + inline void clear_has_stbuf(); + inline void set_has_to_set(); + inline void clear_has_to_set(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::xtreemfs::pbrpc::Stat* stbuf_; + ::google::protobuf::uint32 to_set_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static setattrRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class setxattrRequest : public ::google::protobuf::Message { + public: + setxattrRequest(); + virtual ~setxattrRequest(); + + setxattrRequest(const setxattrRequest& from); + + inline setxattrRequest& operator=(const setxattrRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const setxattrRequest& default_instance(); + + void Swap(setxattrRequest* other); + + // implements Message ---------------------------------------------- + + setxattrRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const setxattrRequest& from); + void MergeFrom(const setxattrRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + inline void set_allocated_name(::std::string* name); + + // required string value = 4; + inline bool has_value() const; + inline void clear_value(); + static const int kValueFieldNumber = 4; + inline const ::std::string& value() const; + inline void set_value(const ::std::string& value); + inline void set_value(const char* value); + inline void set_value(const char* value, size_t size); + inline ::std::string* mutable_value(); + inline ::std::string* release_value(); + inline void set_allocated_value(::std::string* value); + + // optional bytes value_bytes_string = 6; + inline bool has_value_bytes_string() const; + inline void clear_value_bytes_string(); + static const int kValueBytesStringFieldNumber = 6; + inline const ::std::string& value_bytes_string() const; + inline void set_value_bytes_string(const ::std::string& value); + inline void set_value_bytes_string(const char* value); + inline void set_value_bytes_string(const void* value, size_t size); + inline ::std::string* mutable_value_bytes_string(); + inline ::std::string* release_value_bytes_string(); + inline void set_allocated_value_bytes_string(::std::string* value_bytes_string); + + // required fixed32 flags = 5; + inline bool has_flags() const; + inline void clear_flags(); + static const int kFlagsFieldNumber = 5; + inline ::google::protobuf::uint32 flags() const; + inline void set_flags(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.setxattrRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_value(); + inline void clear_has_value(); + inline void set_has_value_bytes_string(); + inline void clear_has_value_bytes_string(); + inline void set_has_flags(); + inline void clear_has_flags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::std::string* name_; + ::std::string* value_; + ::std::string* value_bytes_string_; + ::google::protobuf::uint32 flags_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static setxattrRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class statvfsRequest : public ::google::protobuf::Message { + public: + statvfsRequest(); + virtual ~statvfsRequest(); + + statvfsRequest(const statvfsRequest& from); + + inline statvfsRequest& operator=(const statvfsRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const statvfsRequest& default_instance(); + + void Swap(statvfsRequest* other); + + // implements Message ---------------------------------------------- + + statvfsRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const statvfsRequest& from); + void MergeFrom(const statvfsRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required fixed64 known_etag = 5; + inline bool has_known_etag() const; + inline void clear_known_etag(); + static const int kKnownEtagFieldNumber = 5; + inline ::google::protobuf::uint64 known_etag() const; + inline void set_known_etag(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.statvfsRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_known_etag(); + inline void clear_has_known_etag(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::google::protobuf::uint64 known_etag_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static statvfsRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class symlinkRequest : public ::google::protobuf::Message { + public: + symlinkRequest(); + virtual ~symlinkRequest(); + + symlinkRequest(const symlinkRequest& from); + + inline symlinkRequest& operator=(const symlinkRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const symlinkRequest& default_instance(); + + void Swap(symlinkRequest* other); + + // implements Message ---------------------------------------------- + + symlinkRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const symlinkRequest& from); + void MergeFrom(const symlinkRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string target_path = 2; + inline bool has_target_path() const; + inline void clear_target_path(); + static const int kTargetPathFieldNumber = 2; + inline const ::std::string& target_path() const; + inline void set_target_path(const ::std::string& value); + inline void set_target_path(const char* value); + inline void set_target_path(const char* value, size_t size); + inline ::std::string* mutable_target_path(); + inline ::std::string* release_target_path(); + inline void set_allocated_target_path(::std::string* target_path); + + // required string link_path = 3; + inline bool has_link_path() const; + inline void clear_link_path(); + static const int kLinkPathFieldNumber = 3; + inline const ::std::string& link_path() const; + inline void set_link_path(const ::std::string& value); + inline void set_link_path(const char* value); + inline void set_link_path(const char* value, size_t size); + inline ::std::string* mutable_link_path(); + inline ::std::string* release_link_path(); + inline void set_allocated_link_path(::std::string* link_path); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.symlinkRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_target_path(); + inline void clear_has_target_path(); + inline void set_has_link_path(); + inline void clear_has_link_path(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* target_path_; + ::std::string* link_path_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static symlinkRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class unlinkRequest : public ::google::protobuf::Message { + public: + unlinkRequest(); + virtual ~unlinkRequest(); + + unlinkRequest(const unlinkRequest& from); + + inline unlinkRequest& operator=(const unlinkRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const unlinkRequest& default_instance(); + + void Swap(unlinkRequest* other); + + // implements Message ---------------------------------------------- + + unlinkRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const unlinkRequest& from); + void MergeFrom(const unlinkRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.unlinkRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static unlinkRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class unlinkResponse : public ::google::protobuf::Message { + public: + unlinkResponse(); + virtual ~unlinkResponse(); + + unlinkResponse(const unlinkResponse& from); + + inline unlinkResponse& operator=(const unlinkResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const unlinkResponse& default_instance(); + + void Swap(unlinkResponse* other); + + // implements Message ---------------------------------------------- + + unlinkResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const unlinkResponse& from); + void MergeFrom(const unlinkResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 timestamp_s = 1; + inline bool has_timestamp_s() const; + inline void clear_timestamp_s(); + static const int kTimestampSFieldNumber = 1; + inline ::google::protobuf::uint32 timestamp_s() const; + inline void set_timestamp_s(::google::protobuf::uint32 value); + + // optional .xtreemfs.pbrpc.FileCredentials creds = 2; + inline bool has_creds() const; + inline void clear_creds(); + static const int kCredsFieldNumber = 2; + inline const ::xtreemfs::pbrpc::FileCredentials& creds() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_creds(); + inline ::xtreemfs::pbrpc::FileCredentials* release_creds(); + inline void set_allocated_creds(::xtreemfs::pbrpc::FileCredentials* creds); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.unlinkResponse) + private: + inline void set_has_timestamp_s(); + inline void clear_has_timestamp_s(); + inline void set_has_creds(); + inline void clear_has_creds(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* creds_; + ::google::protobuf::uint32 timestamp_s_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static unlinkResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class accessRequest : public ::google::protobuf::Message { + public: + accessRequest(); + virtual ~accessRequest(); + + accessRequest(const accessRequest& from); + + inline accessRequest& operator=(const accessRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const accessRequest& default_instance(); + + void Swap(accessRequest* other); + + // implements Message ---------------------------------------------- + + accessRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const accessRequest& from); + void MergeFrom(const accessRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // required fixed32 flags = 3; + inline bool has_flags() const; + inline void clear_flags(); + static const int kFlagsFieldNumber = 3; + inline ::google::protobuf::uint32 flags() const; + inline void set_flags(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.accessRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_flags(); + inline void clear_has_flags(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + ::std::string* path_; + ::google::protobuf::uint32 flags_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static accessRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_check_file_existsRequest : public ::google::protobuf::Message { + public: + xtreemfs_check_file_existsRequest(); + virtual ~xtreemfs_check_file_existsRequest(); + + xtreemfs_check_file_existsRequest(const xtreemfs_check_file_existsRequest& from); + + inline xtreemfs_check_file_existsRequest& operator=(const xtreemfs_check_file_existsRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_check_file_existsRequest& default_instance(); + + void Swap(xtreemfs_check_file_existsRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_check_file_existsRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_check_file_existsRequest& from); + void MergeFrom(const xtreemfs_check_file_existsRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_id = 1; + inline bool has_volume_id() const; + inline void clear_volume_id(); + static const int kVolumeIdFieldNumber = 1; + inline const ::std::string& volume_id() const; + inline void set_volume_id(const ::std::string& value); + inline void set_volume_id(const char* value); + inline void set_volume_id(const char* value, size_t size); + inline ::std::string* mutable_volume_id(); + inline ::std::string* release_volume_id(); + inline void set_allocated_volume_id(::std::string* volume_id); + + // repeated string file_ids = 2; + inline int file_ids_size() const; + inline void clear_file_ids(); + static const int kFileIdsFieldNumber = 2; + inline const ::std::string& file_ids(int index) const; + inline ::std::string* mutable_file_ids(int index); + inline void set_file_ids(int index, const ::std::string& value); + inline void set_file_ids(int index, const char* value); + inline void set_file_ids(int index, const char* value, size_t size); + inline ::std::string* add_file_ids(); + inline void add_file_ids(const ::std::string& value); + inline void add_file_ids(const char* value); + inline void add_file_ids(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& file_ids() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_file_ids(); + + // required string osd_uuid = 3; + inline bool has_osd_uuid() const; + inline void clear_osd_uuid(); + static const int kOsdUuidFieldNumber = 3; + inline const ::std::string& osd_uuid() const; + inline void set_osd_uuid(const ::std::string& value); + inline void set_osd_uuid(const char* value); + inline void set_osd_uuid(const char* value, size_t size); + inline ::std::string* mutable_osd_uuid(); + inline ::std::string* release_osd_uuid(); + inline void set_allocated_osd_uuid(::std::string* osd_uuid); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_check_file_existsRequest) + private: + inline void set_has_volume_id(); + inline void clear_has_volume_id(); + inline void set_has_osd_uuid(); + inline void clear_has_osd_uuid(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_id_; + ::google::protobuf::RepeatedPtrField< ::std::string> file_ids_; + ::std::string* osd_uuid_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_check_file_existsRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_check_file_existsResponse : public ::google::protobuf::Message { + public: + xtreemfs_check_file_existsResponse(); + virtual ~xtreemfs_check_file_existsResponse(); + + xtreemfs_check_file_existsResponse(const xtreemfs_check_file_existsResponse& from); + + inline xtreemfs_check_file_existsResponse& operator=(const xtreemfs_check_file_existsResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_check_file_existsResponse& default_instance(); + + void Swap(xtreemfs_check_file_existsResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_check_file_existsResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_check_file_existsResponse& from); + void MergeFrom(const xtreemfs_check_file_existsResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef xtreemfs_check_file_existsResponse_FILE_STATE FILE_STATE; + static const FILE_STATE DELETED = xtreemfs_check_file_existsResponse_FILE_STATE_DELETED; + static const FILE_STATE REGISTERED = xtreemfs_check_file_existsResponse_FILE_STATE_REGISTERED; + static const FILE_STATE ABANDONED = xtreemfs_check_file_existsResponse_FILE_STATE_ABANDONED; + static inline bool FILE_STATE_IsValid(int value) { + return xtreemfs_check_file_existsResponse_FILE_STATE_IsValid(value); + } + static const FILE_STATE FILE_STATE_MIN = + xtreemfs_check_file_existsResponse_FILE_STATE_FILE_STATE_MIN; + static const FILE_STATE FILE_STATE_MAX = + xtreemfs_check_file_existsResponse_FILE_STATE_FILE_STATE_MAX; + static const int FILE_STATE_ARRAYSIZE = + xtreemfs_check_file_existsResponse_FILE_STATE_FILE_STATE_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + FILE_STATE_descriptor() { + return xtreemfs_check_file_existsResponse_FILE_STATE_descriptor(); + } + static inline const ::std::string& FILE_STATE_Name(FILE_STATE value) { + return xtreemfs_check_file_existsResponse_FILE_STATE_Name(value); + } + static inline bool FILE_STATE_Parse(const ::std::string& name, + FILE_STATE* value) { + return xtreemfs_check_file_existsResponse_FILE_STATE_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // required bool volume_exists = 1; + inline bool has_volume_exists() const; + inline void clear_volume_exists(); + static const int kVolumeExistsFieldNumber = 1; + inline bool volume_exists() const; + inline void set_volume_exists(bool value); + + // repeated .xtreemfs.pbrpc.xtreemfs_check_file_existsResponse.FILE_STATE file_states = 2 [packed = true]; + inline int file_states_size() const; + inline void clear_file_states(); + static const int kFileStatesFieldNumber = 2; + inline ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE file_states(int index) const; + inline void set_file_states(int index, ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE value); + inline void add_file_states(::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE value); + inline const ::google::protobuf::RepeatedField& file_states() const; + inline ::google::protobuf::RepeatedField* mutable_file_states(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_check_file_existsResponse) + private: + inline void set_has_volume_exists(); + inline void clear_has_volume_exists(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedField file_states_; + mutable int _file_states_cached_byte_size_; + bool volume_exists_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_check_file_existsResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_dump_restore_databaseRequest : public ::google::protobuf::Message { + public: + xtreemfs_dump_restore_databaseRequest(); + virtual ~xtreemfs_dump_restore_databaseRequest(); + + xtreemfs_dump_restore_databaseRequest(const xtreemfs_dump_restore_databaseRequest& from); + + inline xtreemfs_dump_restore_databaseRequest& operator=(const xtreemfs_dump_restore_databaseRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_dump_restore_databaseRequest& default_instance(); + + void Swap(xtreemfs_dump_restore_databaseRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_dump_restore_databaseRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_dump_restore_databaseRequest& from); + void MergeFrom(const xtreemfs_dump_restore_databaseRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string dump_file = 1; + inline bool has_dump_file() const; + inline void clear_dump_file(); + static const int kDumpFileFieldNumber = 1; + inline const ::std::string& dump_file() const; + inline void set_dump_file(const ::std::string& value); + inline void set_dump_file(const char* value); + inline void set_dump_file(const char* value, size_t size); + inline ::std::string* mutable_dump_file(); + inline ::std::string* release_dump_file(); + inline void set_allocated_dump_file(::std::string* dump_file); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_dump_restore_databaseRequest) + private: + inline void set_has_dump_file(); + inline void clear_has_dump_file(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* dump_file_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_dump_restore_databaseRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_get_suitable_osdsRequest : public ::google::protobuf::Message { + public: + xtreemfs_get_suitable_osdsRequest(); + virtual ~xtreemfs_get_suitable_osdsRequest(); + + xtreemfs_get_suitable_osdsRequest(const xtreemfs_get_suitable_osdsRequest& from); + + inline xtreemfs_get_suitable_osdsRequest& operator=(const xtreemfs_get_suitable_osdsRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_get_suitable_osdsRequest& default_instance(); + + void Swap(xtreemfs_get_suitable_osdsRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_get_suitable_osdsRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_get_suitable_osdsRequest& from); + void MergeFrom(const xtreemfs_get_suitable_osdsRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // optional string path = 3; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 3; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // optional string volume_name = 4; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 4; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required fixed32 num_osds = 2; + inline bool has_num_osds() const; + inline void clear_num_osds(); + static const int kNumOsdsFieldNumber = 2; + inline ::google::protobuf::uint32 num_osds() const; + inline void set_num_osds(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_get_suitable_osdsRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_num_osds(); + inline void clear_has_num_osds(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + ::std::string* path_; + ::std::string* volume_name_; + ::google::protobuf::uint32 num_osds_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_get_suitable_osdsRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_get_suitable_osdsResponse : public ::google::protobuf::Message { + public: + xtreemfs_get_suitable_osdsResponse(); + virtual ~xtreemfs_get_suitable_osdsResponse(); + + xtreemfs_get_suitable_osdsResponse(const xtreemfs_get_suitable_osdsResponse& from); + + inline xtreemfs_get_suitable_osdsResponse& operator=(const xtreemfs_get_suitable_osdsResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_get_suitable_osdsResponse& default_instance(); + + void Swap(xtreemfs_get_suitable_osdsResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_get_suitable_osdsResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_get_suitable_osdsResponse& from); + void MergeFrom(const xtreemfs_get_suitable_osdsResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated string osd_uuids = 1; + inline int osd_uuids_size() const; + inline void clear_osd_uuids(); + static const int kOsdUuidsFieldNumber = 1; + inline const ::std::string& osd_uuids(int index) const; + inline ::std::string* mutable_osd_uuids(int index); + inline void set_osd_uuids(int index, const ::std::string& value); + inline void set_osd_uuids(int index, const char* value); + inline void set_osd_uuids(int index, const char* value, size_t size); + inline ::std::string* add_osd_uuids(); + inline void add_osd_uuids(const ::std::string& value); + inline void add_osd_uuids(const char* value); + inline void add_osd_uuids(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& osd_uuids() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_osd_uuids(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_get_suitable_osdsResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::std::string> osd_uuids_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_get_suitable_osdsResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class timestampResponse : public ::google::protobuf::Message { + public: + timestampResponse(); + virtual ~timestampResponse(); + + timestampResponse(const timestampResponse& from); + + inline timestampResponse& operator=(const timestampResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const timestampResponse& default_instance(); + + void Swap(timestampResponse* other); + + // implements Message ---------------------------------------------- + + timestampResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const timestampResponse& from); + void MergeFrom(const timestampResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 timestamp_s = 1; + inline bool has_timestamp_s() const; + inline void clear_timestamp_s(); + static const int kTimestampSFieldNumber = 1; + inline ::google::protobuf::uint32 timestamp_s() const; + inline void set_timestamp_s(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.timestampResponse) + private: + inline void set_has_timestamp_s(); + inline void clear_has_timestamp_s(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 timestamp_s_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static timestampResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class stringMessage : public ::google::protobuf::Message { + public: + stringMessage(); + virtual ~stringMessage(); + + stringMessage(const stringMessage& from); + + inline stringMessage& operator=(const stringMessage& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const stringMessage& default_instance(); + + void Swap(stringMessage* other); + + // implements Message ---------------------------------------------- + + stringMessage* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const stringMessage& from); + void MergeFrom(const stringMessage& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string a_string = 1; + inline bool has_a_string() const; + inline void clear_a_string(); + static const int kAStringFieldNumber = 1; + inline const ::std::string& a_string() const; + inline void set_a_string(const ::std::string& value); + inline void set_a_string(const char* value); + inline void set_a_string(const char* value, size_t size); + inline ::std::string* mutable_a_string(); + inline ::std::string* release_a_string(); + inline void set_allocated_a_string(::std::string* a_string); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.stringMessage) + private: + inline void set_has_a_string(); + inline void clear_has_a_string(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* a_string_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static stringMessage* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_listdirRequest : public ::google::protobuf::Message { + public: + xtreemfs_listdirRequest(); + virtual ~xtreemfs_listdirRequest(); + + xtreemfs_listdirRequest(const xtreemfs_listdirRequest& from); + + inline xtreemfs_listdirRequest& operator=(const xtreemfs_listdirRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_listdirRequest& default_instance(); + + void Swap(xtreemfs_listdirRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_listdirRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_listdirRequest& from); + void MergeFrom(const xtreemfs_listdirRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string path = 1; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 1; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_listdirRequest) + private: + inline void set_has_path(); + inline void clear_has_path(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* path_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_listdirRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_listdirResponse : public ::google::protobuf::Message { + public: + xtreemfs_listdirResponse(); + virtual ~xtreemfs_listdirResponse(); + + xtreemfs_listdirResponse(const xtreemfs_listdirResponse& from); + + inline xtreemfs_listdirResponse& operator=(const xtreemfs_listdirResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_listdirResponse& default_instance(); + + void Swap(xtreemfs_listdirResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_listdirResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_listdirResponse& from); + void MergeFrom(const xtreemfs_listdirResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated string names = 1; + inline int names_size() const; + inline void clear_names(); + static const int kNamesFieldNumber = 1; + inline const ::std::string& names(int index) const; + inline ::std::string* mutable_names(int index); + inline void set_names(int index, const ::std::string& value); + inline void set_names(int index, const char* value); + inline void set_names(int index, const char* value, size_t size); + inline ::std::string* add_names(); + inline void add_names(const ::std::string& value); + inline void add_names(const char* value); + inline void add_names(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& names() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_names(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_listdirResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::std::string> names_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_listdirResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_replica_addRequest : public ::google::protobuf::Message { + public: + xtreemfs_replica_addRequest(); + virtual ~xtreemfs_replica_addRequest(); + + xtreemfs_replica_addRequest(const xtreemfs_replica_addRequest& from); + + inline xtreemfs_replica_addRequest& operator=(const xtreemfs_replica_addRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_replica_addRequest& default_instance(); + + void Swap(xtreemfs_replica_addRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_replica_addRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_replica_addRequest& from); + void MergeFrom(const xtreemfs_replica_addRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // optional string path = 3; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 3; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // optional string volume_name = 4; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 4; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required .xtreemfs.pbrpc.Replica new_replica = 2; + inline bool has_new_replica() const; + inline void clear_new_replica(); + static const int kNewReplicaFieldNumber = 2; + inline const ::xtreemfs::pbrpc::Replica& new_replica() const; + inline ::xtreemfs::pbrpc::Replica* mutable_new_replica(); + inline ::xtreemfs::pbrpc::Replica* release_new_replica(); + inline void set_allocated_new_replica(::xtreemfs::pbrpc::Replica* new_replica); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_replica_addRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_new_replica(); + inline void clear_has_new_replica(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + ::std::string* path_; + ::std::string* volume_name_; + ::xtreemfs::pbrpc::Replica* new_replica_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_replica_addRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_replica_listRequest : public ::google::protobuf::Message { + public: + xtreemfs_replica_listRequest(); + virtual ~xtreemfs_replica_listRequest(); + + xtreemfs_replica_listRequest(const xtreemfs_replica_listRequest& from); + + inline xtreemfs_replica_listRequest& operator=(const xtreemfs_replica_listRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_replica_listRequest& default_instance(); + + void Swap(xtreemfs_replica_listRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_replica_listRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_replica_listRequest& from); + void MergeFrom(const xtreemfs_replica_listRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // optional string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // optional string volume_name = 3; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 3; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_replica_listRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + ::std::string* path_; + ::std::string* volume_name_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_replica_listRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_get_xlocsetRequest : public ::google::protobuf::Message { + public: + xtreemfs_get_xlocsetRequest(); + virtual ~xtreemfs_get_xlocsetRequest(); + + xtreemfs_get_xlocsetRequest(const xtreemfs_get_xlocsetRequest& from); + + inline xtreemfs_get_xlocsetRequest& operator=(const xtreemfs_get_xlocsetRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_get_xlocsetRequest& default_instance(); + + void Swap(xtreemfs_get_xlocsetRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_get_xlocsetRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_get_xlocsetRequest& from); + void MergeFrom(const xtreemfs_get_xlocsetRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // optional string path = 2; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 2; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // optional string volume_name = 3; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 3; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // optional .xtreemfs.pbrpc.XCap xcap = 4; + inline bool has_xcap() const; + inline void clear_xcap(); + static const int kXcapFieldNumber = 4; + inline const ::xtreemfs::pbrpc::XCap& xcap() const; + inline ::xtreemfs::pbrpc::XCap* mutable_xcap(); + inline ::xtreemfs::pbrpc::XCap* release_xcap(); + inline void set_allocated_xcap(::xtreemfs::pbrpc::XCap* xcap); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_get_xlocsetRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_xcap(); + inline void clear_has_xcap(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + ::std::string* path_; + ::std::string* volume_name_; + ::xtreemfs::pbrpc::XCap* xcap_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_get_xlocsetRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_replica_removeRequest : public ::google::protobuf::Message { + public: + xtreemfs_replica_removeRequest(); + virtual ~xtreemfs_replica_removeRequest(); + + xtreemfs_replica_removeRequest(const xtreemfs_replica_removeRequest& from); + + inline xtreemfs_replica_removeRequest& operator=(const xtreemfs_replica_removeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_replica_removeRequest& default_instance(); + + void Swap(xtreemfs_replica_removeRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_replica_removeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_replica_removeRequest& from); + void MergeFrom(const xtreemfs_replica_removeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // optional string path = 3; + inline bool has_path() const; + inline void clear_path(); + static const int kPathFieldNumber = 3; + inline const ::std::string& path() const; + inline void set_path(const ::std::string& value); + inline void set_path(const char* value); + inline void set_path(const char* value, size_t size); + inline ::std::string* mutable_path(); + inline ::std::string* release_path(); + inline void set_allocated_path(::std::string* path); + + // optional string volume_name = 4; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 4; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // required string osd_uuid = 2; + inline bool has_osd_uuid() const; + inline void clear_osd_uuid(); + static const int kOsdUuidFieldNumber = 2; + inline const ::std::string& osd_uuid() const; + inline void set_osd_uuid(const ::std::string& value); + inline void set_osd_uuid(const char* value); + inline void set_osd_uuid(const char* value, size_t size); + inline ::std::string* mutable_osd_uuid(); + inline ::std::string* release_osd_uuid(); + inline void set_allocated_osd_uuid(::std::string* osd_uuid); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_replica_removeRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_path(); + inline void clear_has_path(); + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + inline void set_has_osd_uuid(); + inline void clear_has_osd_uuid(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + ::std::string* path_; + ::std::string* volume_name_; + ::std::string* osd_uuid_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_replica_removeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_restore_fileRequest : public ::google::protobuf::Message { + public: + xtreemfs_restore_fileRequest(); + virtual ~xtreemfs_restore_fileRequest(); + + xtreemfs_restore_fileRequest(const xtreemfs_restore_fileRequest& from); + + inline xtreemfs_restore_fileRequest& operator=(const xtreemfs_restore_fileRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_restore_fileRequest& default_instance(); + + void Swap(xtreemfs_restore_fileRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_restore_fileRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_restore_fileRequest& from); + void MergeFrom(const xtreemfs_restore_fileRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string file_path = 1; + inline bool has_file_path() const; + inline void clear_file_path(); + static const int kFilePathFieldNumber = 1; + inline const ::std::string& file_path() const; + inline void set_file_path(const ::std::string& value); + inline void set_file_path(const char* value); + inline void set_file_path(const char* value, size_t size); + inline ::std::string* mutable_file_path(); + inline ::std::string* release_file_path(); + inline void set_allocated_file_path(::std::string* file_path); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 file_size = 3; + inline bool has_file_size() const; + inline void clear_file_size(); + static const int kFileSizeFieldNumber = 3; + inline ::google::protobuf::uint64 file_size() const; + inline void set_file_size(::google::protobuf::uint64 value); + + // required string osd_uuid = 4; + inline bool has_osd_uuid() const; + inline void clear_osd_uuid(); + static const int kOsdUuidFieldNumber = 4; + inline const ::std::string& osd_uuid() const; + inline void set_osd_uuid(const ::std::string& value); + inline void set_osd_uuid(const char* value); + inline void set_osd_uuid(const char* value, size_t size); + inline ::std::string* mutable_osd_uuid(); + inline ::std::string* release_osd_uuid(); + inline void set_allocated_osd_uuid(::std::string* osd_uuid); + + // required fixed32 stripe_size = 5; + inline bool has_stripe_size() const; + inline void clear_stripe_size(); + static const int kStripeSizeFieldNumber = 5; + inline ::google::protobuf::uint32 stripe_size() const; + inline void set_stripe_size(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_restore_fileRequest) + private: + inline void set_has_file_path(); + inline void clear_has_file_path(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_file_size(); + inline void clear_has_file_size(); + inline void set_has_osd_uuid(); + inline void clear_has_osd_uuid(); + inline void set_has_stripe_size(); + inline void clear_has_stripe_size(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_path_; + ::std::string* file_id_; + ::google::protobuf::uint64 file_size_; + ::std::string* osd_uuid_; + ::google::protobuf::uint32 stripe_size_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_restore_fileRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rmvolRequest : public ::google::protobuf::Message { + public: + xtreemfs_rmvolRequest(); + virtual ~xtreemfs_rmvolRequest(); + + xtreemfs_rmvolRequest(const xtreemfs_rmvolRequest& from); + + inline xtreemfs_rmvolRequest& operator=(const xtreemfs_rmvolRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rmvolRequest& default_instance(); + + void Swap(xtreemfs_rmvolRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rmvolRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rmvolRequest& from); + void MergeFrom(const xtreemfs_rmvolRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string volume_name = 1; + inline bool has_volume_name() const; + inline void clear_volume_name(); + static const int kVolumeNameFieldNumber = 1; + inline const ::std::string& volume_name() const; + inline void set_volume_name(const ::std::string& value); + inline void set_volume_name(const char* value); + inline void set_volume_name(const char* value, size_t size); + inline ::std::string* mutable_volume_name(); + inline ::std::string* release_volume_name(); + inline void set_allocated_volume_name(::std::string* volume_name); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rmvolRequest) + private: + inline void set_has_volume_name(); + inline void clear_has_volume_name(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* volume_name_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rmvolRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_update_file_sizeRequest : public ::google::protobuf::Message { + public: + xtreemfs_update_file_sizeRequest(); + virtual ~xtreemfs_update_file_sizeRequest(); + + xtreemfs_update_file_sizeRequest(const xtreemfs_update_file_sizeRequest& from); + + inline xtreemfs_update_file_sizeRequest& operator=(const xtreemfs_update_file_sizeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_update_file_sizeRequest& default_instance(); + + void Swap(xtreemfs_update_file_sizeRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_update_file_sizeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_update_file_sizeRequest& from); + void MergeFrom(const xtreemfs_update_file_sizeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.XCap xcap = 1; + inline bool has_xcap() const; + inline void clear_xcap(); + static const int kXcapFieldNumber = 1; + inline const ::xtreemfs::pbrpc::XCap& xcap() const; + inline ::xtreemfs::pbrpc::XCap* mutable_xcap(); + inline ::xtreemfs::pbrpc::XCap* release_xcap(); + inline void set_allocated_xcap(::xtreemfs::pbrpc::XCap* xcap); + + // required .xtreemfs.pbrpc.OSDWriteResponse osd_write_response = 2; + inline bool has_osd_write_response() const; + inline void clear_osd_write_response(); + static const int kOsdWriteResponseFieldNumber = 2; + inline const ::xtreemfs::pbrpc::OSDWriteResponse& osd_write_response() const; + inline ::xtreemfs::pbrpc::OSDWriteResponse* mutable_osd_write_response(); + inline ::xtreemfs::pbrpc::OSDWriteResponse* release_osd_write_response(); + inline void set_allocated_osd_write_response(::xtreemfs::pbrpc::OSDWriteResponse* osd_write_response); + + // optional bool close_file = 3; + inline bool has_close_file() const; + inline void clear_close_file(); + static const int kCloseFileFieldNumber = 3; + inline bool close_file() const; + inline void set_close_file(bool value); + + // optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 4; + inline bool has_coordinates() const; + inline void clear_coordinates(); + static const int kCoordinatesFieldNumber = 4; + inline const ::xtreemfs::pbrpc::VivaldiCoordinates& coordinates() const; + inline ::xtreemfs::pbrpc::VivaldiCoordinates* mutable_coordinates(); + inline ::xtreemfs::pbrpc::VivaldiCoordinates* release_coordinates(); + inline void set_allocated_coordinates(::xtreemfs::pbrpc::VivaldiCoordinates* coordinates); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_update_file_sizeRequest) + private: + inline void set_has_xcap(); + inline void clear_has_xcap(); + inline void set_has_osd_write_response(); + inline void clear_has_osd_write_response(); + inline void set_has_close_file(); + inline void clear_has_close_file(); + inline void set_has_coordinates(); + inline void clear_has_coordinates(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::XCap* xcap_; + ::xtreemfs::pbrpc::OSDWriteResponse* osd_write_response_; + ::xtreemfs::pbrpc::VivaldiCoordinates* coordinates_; + bool close_file_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_update_file_sizeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_set_replica_update_policyRequest : public ::google::protobuf::Message { + public: + xtreemfs_set_replica_update_policyRequest(); + virtual ~xtreemfs_set_replica_update_policyRequest(); + + xtreemfs_set_replica_update_policyRequest(const xtreemfs_set_replica_update_policyRequest& from); + + inline xtreemfs_set_replica_update_policyRequest& operator=(const xtreemfs_set_replica_update_policyRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_set_replica_update_policyRequest& default_instance(); + + void Swap(xtreemfs_set_replica_update_policyRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_set_replica_update_policyRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_set_replica_update_policyRequest& from); + void MergeFrom(const xtreemfs_set_replica_update_policyRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required string update_policy = 2; + inline bool has_update_policy() const; + inline void clear_update_policy(); + static const int kUpdatePolicyFieldNumber = 2; + inline const ::std::string& update_policy() const; + inline void set_update_policy(const ::std::string& value); + inline void set_update_policy(const char* value); + inline void set_update_policy(const char* value, size_t size); + inline ::std::string* mutable_update_policy(); + inline ::std::string* release_update_policy(); + inline void set_allocated_update_policy(::std::string* update_policy); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_set_replica_update_policyRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_update_policy(); + inline void clear_has_update_policy(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + ::std::string* update_policy_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_set_replica_update_policyRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_set_replica_update_policyResponse : public ::google::protobuf::Message { + public: + xtreemfs_set_replica_update_policyResponse(); + virtual ~xtreemfs_set_replica_update_policyResponse(); + + xtreemfs_set_replica_update_policyResponse(const xtreemfs_set_replica_update_policyResponse& from); + + inline xtreemfs_set_replica_update_policyResponse& operator=(const xtreemfs_set_replica_update_policyResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_set_replica_update_policyResponse& default_instance(); + + void Swap(xtreemfs_set_replica_update_policyResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_set_replica_update_policyResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_set_replica_update_policyResponse& from); + void MergeFrom(const xtreemfs_set_replica_update_policyResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string old_update_policy = 1; + inline bool has_old_update_policy() const; + inline void clear_old_update_policy(); + static const int kOldUpdatePolicyFieldNumber = 1; + inline const ::std::string& old_update_policy() const; + inline void set_old_update_policy(const ::std::string& value); + inline void set_old_update_policy(const char* value); + inline void set_old_update_policy(const char* value, size_t size); + inline ::std::string* mutable_old_update_policy(); + inline ::std::string* release_old_update_policy(); + inline void set_allocated_old_update_policy(::std::string* old_update_policy); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_set_replica_update_policyResponse) + private: + inline void set_has_old_update_policy(); + inline void clear_has_old_update_policy(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* old_update_policy_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_set_replica_update_policyResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_set_read_only_xattrRequest : public ::google::protobuf::Message { + public: + xtreemfs_set_read_only_xattrRequest(); + virtual ~xtreemfs_set_read_only_xattrRequest(); + + xtreemfs_set_read_only_xattrRequest(const xtreemfs_set_read_only_xattrRequest& from); + + inline xtreemfs_set_read_only_xattrRequest& operator=(const xtreemfs_set_read_only_xattrRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_set_read_only_xattrRequest& default_instance(); + + void Swap(xtreemfs_set_read_only_xattrRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_set_read_only_xattrRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_set_read_only_xattrRequest& from); + void MergeFrom(const xtreemfs_set_read_only_xattrRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required bool value = 2; + inline bool has_value() const; + inline void clear_value(); + static const int kValueFieldNumber = 2; + inline bool value() const; + inline void set_value(bool value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_set_read_only_xattrRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_value(); + inline void clear_has_value(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + bool value_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_set_read_only_xattrRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_set_read_only_xattrResponse : public ::google::protobuf::Message { + public: + xtreemfs_set_read_only_xattrResponse(); + virtual ~xtreemfs_set_read_only_xattrResponse(); + + xtreemfs_set_read_only_xattrResponse(const xtreemfs_set_read_only_xattrResponse& from); + + inline xtreemfs_set_read_only_xattrResponse& operator=(const xtreemfs_set_read_only_xattrResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_set_read_only_xattrResponse& default_instance(); + + void Swap(xtreemfs_set_read_only_xattrResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_set_read_only_xattrResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_set_read_only_xattrResponse& from); + void MergeFrom(const xtreemfs_set_read_only_xattrResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required bool was_set = 1; + inline bool has_was_set() const; + inline void clear_was_set(); + static const int kWasSetFieldNumber = 1; + inline bool was_set() const; + inline void set_was_set(bool value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_set_read_only_xattrResponse) + private: + inline void set_has_was_set(); + inline void clear_has_was_set(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + bool was_set_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_set_read_only_xattrResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_get_file_credentialsRequest : public ::google::protobuf::Message { + public: + xtreemfs_get_file_credentialsRequest(); + virtual ~xtreemfs_get_file_credentialsRequest(); + + xtreemfs_get_file_credentialsRequest(const xtreemfs_get_file_credentialsRequest& from); + + inline xtreemfs_get_file_credentialsRequest& operator=(const xtreemfs_get_file_credentialsRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_get_file_credentialsRequest& default_instance(); + + void Swap(xtreemfs_get_file_credentialsRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_get_file_credentialsRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_get_file_credentialsRequest& from); + void MergeFrom(const xtreemfs_get_file_credentialsRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_get_file_credentialsRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_get_file_credentialsRequest* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// Stat + +// required fixed64 dev = 1; +inline bool Stat::has_dev() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Stat::set_has_dev() { + _has_bits_[0] |= 0x00000001u; +} +inline void Stat::clear_has_dev() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Stat::clear_dev() { + dev_ = GOOGLE_ULONGLONG(0); + clear_has_dev(); +} +inline ::google::protobuf::uint64 Stat::dev() const { + return dev_; +} +inline void Stat::set_dev(::google::protobuf::uint64 value) { + set_has_dev(); + dev_ = value; +} + +// required fixed64 ino = 2; +inline bool Stat::has_ino() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Stat::set_has_ino() { + _has_bits_[0] |= 0x00000002u; +} +inline void Stat::clear_has_ino() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Stat::clear_ino() { + ino_ = GOOGLE_ULONGLONG(0); + clear_has_ino(); +} +inline ::google::protobuf::uint64 Stat::ino() const { + return ino_; +} +inline void Stat::set_ino(::google::protobuf::uint64 value) { + set_has_ino(); + ino_ = value; +} + +// required fixed32 mode = 3; +inline bool Stat::has_mode() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Stat::set_has_mode() { + _has_bits_[0] |= 0x00000004u; +} +inline void Stat::clear_has_mode() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Stat::clear_mode() { + mode_ = 0u; + clear_has_mode(); +} +inline ::google::protobuf::uint32 Stat::mode() const { + return mode_; +} +inline void Stat::set_mode(::google::protobuf::uint32 value) { + set_has_mode(); + mode_ = value; +} + +// required fixed32 nlink = 4; +inline bool Stat::has_nlink() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Stat::set_has_nlink() { + _has_bits_[0] |= 0x00000008u; +} +inline void Stat::clear_has_nlink() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Stat::clear_nlink() { + nlink_ = 0u; + clear_has_nlink(); +} +inline ::google::protobuf::uint32 Stat::nlink() const { + return nlink_; +} +inline void Stat::set_nlink(::google::protobuf::uint32 value) { + set_has_nlink(); + nlink_ = value; +} + +// required string user_id = 5; +inline bool Stat::has_user_id() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Stat::set_has_user_id() { + _has_bits_[0] |= 0x00000010u; +} +inline void Stat::clear_has_user_id() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Stat::clear_user_id() { + if (user_id_ != &::google::protobuf::internal::kEmptyString) { + user_id_->clear(); + } + clear_has_user_id(); +} +inline const ::std::string& Stat::user_id() const { + return *user_id_; +} +inline void Stat::set_user_id(const ::std::string& value) { + set_has_user_id(); + if (user_id_ == &::google::protobuf::internal::kEmptyString) { + user_id_ = new ::std::string; + } + user_id_->assign(value); +} +inline void Stat::set_user_id(const char* value) { + set_has_user_id(); + if (user_id_ == &::google::protobuf::internal::kEmptyString) { + user_id_ = new ::std::string; + } + user_id_->assign(value); +} +inline void Stat::set_user_id(const char* value, size_t size) { + set_has_user_id(); + if (user_id_ == &::google::protobuf::internal::kEmptyString) { + user_id_ = new ::std::string; + } + user_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Stat::mutable_user_id() { + set_has_user_id(); + if (user_id_ == &::google::protobuf::internal::kEmptyString) { + user_id_ = new ::std::string; + } + return user_id_; +} +inline ::std::string* Stat::release_user_id() { + clear_has_user_id(); + if (user_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = user_id_; + user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Stat::set_allocated_user_id(::std::string* user_id) { + if (user_id_ != &::google::protobuf::internal::kEmptyString) { + delete user_id_; + } + if (user_id) { + set_has_user_id(); + user_id_ = user_id; + } else { + clear_has_user_id(); + user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string group_id = 6; +inline bool Stat::has_group_id() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Stat::set_has_group_id() { + _has_bits_[0] |= 0x00000020u; +} +inline void Stat::clear_has_group_id() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Stat::clear_group_id() { + if (group_id_ != &::google::protobuf::internal::kEmptyString) { + group_id_->clear(); + } + clear_has_group_id(); +} +inline const ::std::string& Stat::group_id() const { + return *group_id_; +} +inline void Stat::set_group_id(const ::std::string& value) { + set_has_group_id(); + if (group_id_ == &::google::protobuf::internal::kEmptyString) { + group_id_ = new ::std::string; + } + group_id_->assign(value); +} +inline void Stat::set_group_id(const char* value) { + set_has_group_id(); + if (group_id_ == &::google::protobuf::internal::kEmptyString) { + group_id_ = new ::std::string; + } + group_id_->assign(value); +} +inline void Stat::set_group_id(const char* value, size_t size) { + set_has_group_id(); + if (group_id_ == &::google::protobuf::internal::kEmptyString) { + group_id_ = new ::std::string; + } + group_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Stat::mutable_group_id() { + set_has_group_id(); + if (group_id_ == &::google::protobuf::internal::kEmptyString) { + group_id_ = new ::std::string; + } + return group_id_; +} +inline ::std::string* Stat::release_group_id() { + clear_has_group_id(); + if (group_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = group_id_; + group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Stat::set_allocated_group_id(::std::string* group_id) { + if (group_id_ != &::google::protobuf::internal::kEmptyString) { + delete group_id_; + } + if (group_id) { + set_has_group_id(); + group_id_ = group_id; + } else { + clear_has_group_id(); + group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 size = 7; +inline bool Stat::has_size() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void Stat::set_has_size() { + _has_bits_[0] |= 0x00000040u; +} +inline void Stat::clear_has_size() { + _has_bits_[0] &= ~0x00000040u; +} +inline void Stat::clear_size() { + size_ = GOOGLE_ULONGLONG(0); + clear_has_size(); +} +inline ::google::protobuf::uint64 Stat::size() const { + return size_; +} +inline void Stat::set_size(::google::protobuf::uint64 value) { + set_has_size(); + size_ = value; +} + +// required fixed64 atime_ns = 8; +inline bool Stat::has_atime_ns() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void Stat::set_has_atime_ns() { + _has_bits_[0] |= 0x00000080u; +} +inline void Stat::clear_has_atime_ns() { + _has_bits_[0] &= ~0x00000080u; +} +inline void Stat::clear_atime_ns() { + atime_ns_ = GOOGLE_ULONGLONG(0); + clear_has_atime_ns(); +} +inline ::google::protobuf::uint64 Stat::atime_ns() const { + return atime_ns_; +} +inline void Stat::set_atime_ns(::google::protobuf::uint64 value) { + set_has_atime_ns(); + atime_ns_ = value; +} + +// required fixed64 mtime_ns = 9; +inline bool Stat::has_mtime_ns() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void Stat::set_has_mtime_ns() { + _has_bits_[0] |= 0x00000100u; +} +inline void Stat::clear_has_mtime_ns() { + _has_bits_[0] &= ~0x00000100u; +} +inline void Stat::clear_mtime_ns() { + mtime_ns_ = GOOGLE_ULONGLONG(0); + clear_has_mtime_ns(); +} +inline ::google::protobuf::uint64 Stat::mtime_ns() const { + return mtime_ns_; +} +inline void Stat::set_mtime_ns(::google::protobuf::uint64 value) { + set_has_mtime_ns(); + mtime_ns_ = value; +} + +// required fixed64 ctime_ns = 10; +inline bool Stat::has_ctime_ns() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void Stat::set_has_ctime_ns() { + _has_bits_[0] |= 0x00000200u; +} +inline void Stat::clear_has_ctime_ns() { + _has_bits_[0] &= ~0x00000200u; +} +inline void Stat::clear_ctime_ns() { + ctime_ns_ = GOOGLE_ULONGLONG(0); + clear_has_ctime_ns(); +} +inline ::google::protobuf::uint64 Stat::ctime_ns() const { + return ctime_ns_; +} +inline void Stat::set_ctime_ns(::google::protobuf::uint64 value) { + set_has_ctime_ns(); + ctime_ns_ = value; +} + +// required fixed32 blksize = 11; +inline bool Stat::has_blksize() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void Stat::set_has_blksize() { + _has_bits_[0] |= 0x00000400u; +} +inline void Stat::clear_has_blksize() { + _has_bits_[0] &= ~0x00000400u; +} +inline void Stat::clear_blksize() { + blksize_ = 0u; + clear_has_blksize(); +} +inline ::google::protobuf::uint32 Stat::blksize() const { + return blksize_; +} +inline void Stat::set_blksize(::google::protobuf::uint32 value) { + set_has_blksize(); + blksize_ = value; +} + +// optional fixed64 etag = 12; +inline bool Stat::has_etag() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void Stat::set_has_etag() { + _has_bits_[0] |= 0x00000800u; +} +inline void Stat::clear_has_etag() { + _has_bits_[0] &= ~0x00000800u; +} +inline void Stat::clear_etag() { + etag_ = GOOGLE_ULONGLONG(0); + clear_has_etag(); +} +inline ::google::protobuf::uint64 Stat::etag() const { + return etag_; +} +inline void Stat::set_etag(::google::protobuf::uint64 value) { + set_has_etag(); + etag_ = value; +} + +// required fixed32 truncate_epoch = 13; +inline bool Stat::has_truncate_epoch() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void Stat::set_has_truncate_epoch() { + _has_bits_[0] |= 0x00001000u; +} +inline void Stat::clear_has_truncate_epoch() { + _has_bits_[0] &= ~0x00001000u; +} +inline void Stat::clear_truncate_epoch() { + truncate_epoch_ = 0u; + clear_has_truncate_epoch(); +} +inline ::google::protobuf::uint32 Stat::truncate_epoch() const { + return truncate_epoch_; +} +inline void Stat::set_truncate_epoch(::google::protobuf::uint32 value) { + set_has_truncate_epoch(); + truncate_epoch_ = value; +} + +// optional fixed32 attributes = 14; +inline bool Stat::has_attributes() const { + return (_has_bits_[0] & 0x00002000u) != 0; +} +inline void Stat::set_has_attributes() { + _has_bits_[0] |= 0x00002000u; +} +inline void Stat::clear_has_attributes() { + _has_bits_[0] &= ~0x00002000u; +} +inline void Stat::clear_attributes() { + attributes_ = 0u; + clear_has_attributes(); +} +inline ::google::protobuf::uint32 Stat::attributes() const { + return attributes_; +} +inline void Stat::set_attributes(::google::protobuf::uint32 value) { + set_has_attributes(); + attributes_ = value; +} + +// ------------------------------------------------------------------- + +// DirectoryEntry + +// required string name = 1; +inline bool DirectoryEntry::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DirectoryEntry::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void DirectoryEntry::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DirectoryEntry::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& DirectoryEntry::name() const { + return *name_; +} +inline void DirectoryEntry::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void DirectoryEntry::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void DirectoryEntry::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* DirectoryEntry::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* DirectoryEntry::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void DirectoryEntry::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional .xtreemfs.pbrpc.Stat stbuf = 2; +inline bool DirectoryEntry::has_stbuf() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void DirectoryEntry::set_has_stbuf() { + _has_bits_[0] |= 0x00000002u; +} +inline void DirectoryEntry::clear_has_stbuf() { + _has_bits_[0] &= ~0x00000002u; +} +inline void DirectoryEntry::clear_stbuf() { + if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear(); + clear_has_stbuf(); +} +inline const ::xtreemfs::pbrpc::Stat& DirectoryEntry::stbuf() const { + return stbuf_ != NULL ? *stbuf_ : *default_instance_->stbuf_; +} +inline ::xtreemfs::pbrpc::Stat* DirectoryEntry::mutable_stbuf() { + set_has_stbuf(); + if (stbuf_ == NULL) stbuf_ = new ::xtreemfs::pbrpc::Stat; + return stbuf_; +} +inline ::xtreemfs::pbrpc::Stat* DirectoryEntry::release_stbuf() { + clear_has_stbuf(); + ::xtreemfs::pbrpc::Stat* temp = stbuf_; + stbuf_ = NULL; + return temp; +} +inline void DirectoryEntry::set_allocated_stbuf(::xtreemfs::pbrpc::Stat* stbuf) { + delete stbuf_; + stbuf_ = stbuf; + if (stbuf) { + set_has_stbuf(); + } else { + clear_has_stbuf(); + } +} + +// ------------------------------------------------------------------- + +// DirectoryEntries + +// repeated .xtreemfs.pbrpc.DirectoryEntry entries = 1; +inline int DirectoryEntries::entries_size() const { + return entries_.size(); +} +inline void DirectoryEntries::clear_entries() { + entries_.Clear(); +} +inline const ::xtreemfs::pbrpc::DirectoryEntry& DirectoryEntries::entries(int index) const { + return entries_.Get(index); +} +inline ::xtreemfs::pbrpc::DirectoryEntry* DirectoryEntries::mutable_entries(int index) { + return entries_.Mutable(index); +} +inline ::xtreemfs::pbrpc::DirectoryEntry* DirectoryEntries::add_entries() { + return entries_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::DirectoryEntry >& +DirectoryEntries::entries() const { + return entries_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::DirectoryEntry >* +DirectoryEntries::mutable_entries() { + return &entries_; +} + +// ------------------------------------------------------------------- + +// XAttr + +// required string name = 1; +inline bool XAttr::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void XAttr::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void XAttr::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void XAttr::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& XAttr::name() const { + return *name_; +} +inline void XAttr::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void XAttr::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void XAttr::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* XAttr::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* XAttr::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void XAttr::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string value = 2; +inline bool XAttr::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void XAttr::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void XAttr::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void XAttr::clear_value() { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + clear_has_value(); +} +inline const ::std::string& XAttr::value() const { + return *value_; +} +inline void XAttr::set_value(const ::std::string& value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void XAttr::set_value(const char* value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void XAttr::set_value(const char* value, size_t size) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(reinterpret_cast(value), size); +} +inline ::std::string* XAttr::mutable_value() { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + return value_; +} +inline ::std::string* XAttr::release_value() { + clear_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = value_; + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void XAttr::set_allocated_value(::std::string* value) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (value) { + set_has_value(); + value_ = value; + } else { + clear_has_value(); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional bytes value_bytes_string = 3; +inline bool XAttr::has_value_bytes_string() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void XAttr::set_has_value_bytes_string() { + _has_bits_[0] |= 0x00000004u; +} +inline void XAttr::clear_has_value_bytes_string() { + _has_bits_[0] &= ~0x00000004u; +} +inline void XAttr::clear_value_bytes_string() { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + value_bytes_string_->clear(); + } + clear_has_value_bytes_string(); +} +inline const ::std::string& XAttr::value_bytes_string() const { + return *value_bytes_string_; +} +inline void XAttr::set_value_bytes_string(const ::std::string& value) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(value); +} +inline void XAttr::set_value_bytes_string(const char* value) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(value); +} +inline void XAttr::set_value_bytes_string(const void* value, size_t size) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(reinterpret_cast(value), size); +} +inline ::std::string* XAttr::mutable_value_bytes_string() { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + return value_bytes_string_; +} +inline ::std::string* XAttr::release_value_bytes_string() { + clear_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = value_bytes_string_; + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void XAttr::set_allocated_value_bytes_string(::std::string* value_bytes_string) { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + delete value_bytes_string_; + } + if (value_bytes_string) { + set_has_value_bytes_string(); + value_bytes_string_ = value_bytes_string; + } else { + clear_has_value_bytes_string(); + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// Volume + +// required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1; +inline bool Volume::has_access_control_policy() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Volume::set_has_access_control_policy() { + _has_bits_[0] |= 0x00000001u; +} +inline void Volume::clear_has_access_control_policy() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Volume::clear_access_control_policy() { + access_control_policy_ = 1; + clear_has_access_control_policy(); +} +inline ::xtreemfs::pbrpc::AccessControlPolicyType Volume::access_control_policy() const { + return static_cast< ::xtreemfs::pbrpc::AccessControlPolicyType >(access_control_policy_); +} +inline void Volume::set_access_control_policy(::xtreemfs::pbrpc::AccessControlPolicyType value) { + assert(::xtreemfs::pbrpc::AccessControlPolicyType_IsValid(value)); + set_has_access_control_policy(); + access_control_policy_ = value; +} + +// required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 2; +inline bool Volume::has_default_striping_policy() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Volume::set_has_default_striping_policy() { + _has_bits_[0] |= 0x00000002u; +} +inline void Volume::clear_has_default_striping_policy() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Volume::clear_default_striping_policy() { + if (default_striping_policy_ != NULL) default_striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear(); + clear_has_default_striping_policy(); +} +inline const ::xtreemfs::pbrpc::StripingPolicy& Volume::default_striping_policy() const { + return default_striping_policy_ != NULL ? *default_striping_policy_ : *default_instance_->default_striping_policy_; +} +inline ::xtreemfs::pbrpc::StripingPolicy* Volume::mutable_default_striping_policy() { + set_has_default_striping_policy(); + if (default_striping_policy_ == NULL) default_striping_policy_ = new ::xtreemfs::pbrpc::StripingPolicy; + return default_striping_policy_; +} +inline ::xtreemfs::pbrpc::StripingPolicy* Volume::release_default_striping_policy() { + clear_has_default_striping_policy(); + ::xtreemfs::pbrpc::StripingPolicy* temp = default_striping_policy_; + default_striping_policy_ = NULL; + return temp; +} +inline void Volume::set_allocated_default_striping_policy(::xtreemfs::pbrpc::StripingPolicy* default_striping_policy) { + delete default_striping_policy_; + default_striping_policy_ = default_striping_policy; + if (default_striping_policy) { + set_has_default_striping_policy(); + } else { + clear_has_default_striping_policy(); + } +} + +// required string id = 3; +inline bool Volume::has_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Volume::set_has_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void Volume::clear_has_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Volume::clear_id() { + if (id_ != &::google::protobuf::internal::kEmptyString) { + id_->clear(); + } + clear_has_id(); +} +inline const ::std::string& Volume::id() const { + return *id_; +} +inline void Volume::set_id(const ::std::string& value) { + set_has_id(); + if (id_ == &::google::protobuf::internal::kEmptyString) { + id_ = new ::std::string; + } + id_->assign(value); +} +inline void Volume::set_id(const char* value) { + set_has_id(); + if (id_ == &::google::protobuf::internal::kEmptyString) { + id_ = new ::std::string; + } + id_->assign(value); +} +inline void Volume::set_id(const char* value, size_t size) { + set_has_id(); + if (id_ == &::google::protobuf::internal::kEmptyString) { + id_ = new ::std::string; + } + id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Volume::mutable_id() { + set_has_id(); + if (id_ == &::google::protobuf::internal::kEmptyString) { + id_ = new ::std::string; + } + return id_; +} +inline ::std::string* Volume::release_id() { + clear_has_id(); + if (id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = id_; + id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Volume::set_allocated_id(::std::string* id) { + if (id_ != &::google::protobuf::internal::kEmptyString) { + delete id_; + } + if (id) { + set_has_id(); + id_ = id; + } else { + clear_has_id(); + id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 mode = 4; +inline bool Volume::has_mode() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Volume::set_has_mode() { + _has_bits_[0] |= 0x00000008u; +} +inline void Volume::clear_has_mode() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Volume::clear_mode() { + mode_ = 0u; + clear_has_mode(); +} +inline ::google::protobuf::uint32 Volume::mode() const { + return mode_; +} +inline void Volume::set_mode(::google::protobuf::uint32 value) { + set_has_mode(); + mode_ = value; +} + +// required string name = 5; +inline bool Volume::has_name() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Volume::set_has_name() { + _has_bits_[0] |= 0x00000010u; +} +inline void Volume::clear_has_name() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Volume::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& Volume::name() const { + return *name_; +} +inline void Volume::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void Volume::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void Volume::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Volume::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* Volume::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Volume::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string owner_group_id = 6; +inline bool Volume::has_owner_group_id() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void Volume::set_has_owner_group_id() { + _has_bits_[0] |= 0x00000020u; +} +inline void Volume::clear_has_owner_group_id() { + _has_bits_[0] &= ~0x00000020u; +} +inline void Volume::clear_owner_group_id() { + if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) { + owner_group_id_->clear(); + } + clear_has_owner_group_id(); +} +inline const ::std::string& Volume::owner_group_id() const { + return *owner_group_id_; +} +inline void Volume::set_owner_group_id(const ::std::string& value) { + set_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + owner_group_id_ = new ::std::string; + } + owner_group_id_->assign(value); +} +inline void Volume::set_owner_group_id(const char* value) { + set_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + owner_group_id_ = new ::std::string; + } + owner_group_id_->assign(value); +} +inline void Volume::set_owner_group_id(const char* value, size_t size) { + set_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + owner_group_id_ = new ::std::string; + } + owner_group_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Volume::mutable_owner_group_id() { + set_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + owner_group_id_ = new ::std::string; + } + return owner_group_id_; +} +inline ::std::string* Volume::release_owner_group_id() { + clear_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = owner_group_id_; + owner_group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Volume::set_allocated_owner_group_id(::std::string* owner_group_id) { + if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) { + delete owner_group_id_; + } + if (owner_group_id) { + set_has_owner_group_id(); + owner_group_id_ = owner_group_id; + } else { + clear_has_owner_group_id(); + owner_group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string owner_user_id = 7; +inline bool Volume::has_owner_user_id() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void Volume::set_has_owner_user_id() { + _has_bits_[0] |= 0x00000040u; +} +inline void Volume::clear_has_owner_user_id() { + _has_bits_[0] &= ~0x00000040u; +} +inline void Volume::clear_owner_user_id() { + if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) { + owner_user_id_->clear(); + } + clear_has_owner_user_id(); +} +inline const ::std::string& Volume::owner_user_id() const { + return *owner_user_id_; +} +inline void Volume::set_owner_user_id(const ::std::string& value) { + set_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + owner_user_id_ = new ::std::string; + } + owner_user_id_->assign(value); +} +inline void Volume::set_owner_user_id(const char* value) { + set_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + owner_user_id_ = new ::std::string; + } + owner_user_id_->assign(value); +} +inline void Volume::set_owner_user_id(const char* value, size_t size) { + set_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + owner_user_id_ = new ::std::string; + } + owner_user_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Volume::mutable_owner_user_id() { + set_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + owner_user_id_ = new ::std::string; + } + return owner_user_id_; +} +inline ::std::string* Volume::release_owner_user_id() { + clear_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = owner_user_id_; + owner_user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Volume::set_allocated_owner_user_id(::std::string* owner_user_id) { + if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) { + delete owner_user_id_; + } + if (owner_user_id) { + set_has_owner_user_id(); + owner_user_id_ = owner_user_id; + } else { + clear_has_owner_user_id(); + owner_user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// repeated .xtreemfs.pbrpc.KeyValuePair attrs = 8; +inline int Volume::attrs_size() const { + return attrs_.size(); +} +inline void Volume::clear_attrs() { + attrs_.Clear(); +} +inline const ::xtreemfs::pbrpc::KeyValuePair& Volume::attrs(int index) const { + return attrs_.Get(index); +} +inline ::xtreemfs::pbrpc::KeyValuePair* Volume::mutable_attrs(int index) { + return attrs_.Mutable(index); +} +inline ::xtreemfs::pbrpc::KeyValuePair* Volume::add_attrs() { + return attrs_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >& +Volume::attrs() const { + return attrs_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >* +Volume::mutable_attrs() { + return &attrs_; +} + +// optional fixed64 quota = 9; +inline bool Volume::has_quota() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void Volume::set_has_quota() { + _has_bits_[0] |= 0x00000100u; +} +inline void Volume::clear_has_quota() { + _has_bits_[0] &= ~0x00000100u; +} +inline void Volume::clear_quota() { + quota_ = GOOGLE_ULONGLONG(0); + clear_has_quota(); +} +inline ::google::protobuf::uint64 Volume::quota() const { + return quota_; +} +inline void Volume::set_quota(::google::protobuf::uint64 value) { + set_has_quota(); + quota_ = value; +} + +// ------------------------------------------------------------------- + +// Volumes + +// repeated .xtreemfs.pbrpc.Volume volumes = 1; +inline int Volumes::volumes_size() const { + return volumes_.size(); +} +inline void Volumes::clear_volumes() { + volumes_.Clear(); +} +inline const ::xtreemfs::pbrpc::Volume& Volumes::volumes(int index) const { + return volumes_.Get(index); +} +inline ::xtreemfs::pbrpc::Volume* Volumes::mutable_volumes(int index) { + return volumes_.Mutable(index); +} +inline ::xtreemfs::pbrpc::Volume* Volumes::add_volumes() { + return volumes_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Volume >& +Volumes::volumes() const { + return volumes_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Volume >* +Volumes::mutable_volumes() { + return &volumes_; +} + +// ------------------------------------------------------------------- + +// StatVFS + +// required fixed32 bsize = 1; +inline bool StatVFS::has_bsize() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void StatVFS::set_has_bsize() { + _has_bits_[0] |= 0x00000001u; +} +inline void StatVFS::clear_has_bsize() { + _has_bits_[0] &= ~0x00000001u; +} +inline void StatVFS::clear_bsize() { + bsize_ = 0u; + clear_has_bsize(); +} +inline ::google::protobuf::uint32 StatVFS::bsize() const { + return bsize_; +} +inline void StatVFS::set_bsize(::google::protobuf::uint32 value) { + set_has_bsize(); + bsize_ = value; +} + +// required fixed64 bavail = 2; +inline bool StatVFS::has_bavail() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void StatVFS::set_has_bavail() { + _has_bits_[0] |= 0x00000002u; +} +inline void StatVFS::clear_has_bavail() { + _has_bits_[0] &= ~0x00000002u; +} +inline void StatVFS::clear_bavail() { + bavail_ = GOOGLE_ULONGLONG(0); + clear_has_bavail(); +} +inline ::google::protobuf::uint64 StatVFS::bavail() const { + return bavail_; +} +inline void StatVFS::set_bavail(::google::protobuf::uint64 value) { + set_has_bavail(); + bavail_ = value; +} + +// optional fixed64 bfree = 13; +inline bool StatVFS::has_bfree() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void StatVFS::set_has_bfree() { + _has_bits_[0] |= 0x00000004u; +} +inline void StatVFS::clear_has_bfree() { + _has_bits_[0] &= ~0x00000004u; +} +inline void StatVFS::clear_bfree() { + bfree_ = GOOGLE_ULONGLONG(0); + clear_has_bfree(); +} +inline ::google::protobuf::uint64 StatVFS::bfree() const { + return bfree_; +} +inline void StatVFS::set_bfree(::google::protobuf::uint64 value) { + set_has_bfree(); + bfree_ = value; +} + +// required fixed64 blocks = 3; +inline bool StatVFS::has_blocks() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void StatVFS::set_has_blocks() { + _has_bits_[0] |= 0x00000008u; +} +inline void StatVFS::clear_has_blocks() { + _has_bits_[0] &= ~0x00000008u; +} +inline void StatVFS::clear_blocks() { + blocks_ = GOOGLE_ULONGLONG(0); + clear_has_blocks(); +} +inline ::google::protobuf::uint64 StatVFS::blocks() const { + return blocks_; +} +inline void StatVFS::set_blocks(::google::protobuf::uint64 value) { + set_has_blocks(); + blocks_ = value; +} + +// required string fsid = 4; +inline bool StatVFS::has_fsid() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void StatVFS::set_has_fsid() { + _has_bits_[0] |= 0x00000010u; +} +inline void StatVFS::clear_has_fsid() { + _has_bits_[0] &= ~0x00000010u; +} +inline void StatVFS::clear_fsid() { + if (fsid_ != &::google::protobuf::internal::kEmptyString) { + fsid_->clear(); + } + clear_has_fsid(); +} +inline const ::std::string& StatVFS::fsid() const { + return *fsid_; +} +inline void StatVFS::set_fsid(const ::std::string& value) { + set_has_fsid(); + if (fsid_ == &::google::protobuf::internal::kEmptyString) { + fsid_ = new ::std::string; + } + fsid_->assign(value); +} +inline void StatVFS::set_fsid(const char* value) { + set_has_fsid(); + if (fsid_ == &::google::protobuf::internal::kEmptyString) { + fsid_ = new ::std::string; + } + fsid_->assign(value); +} +inline void StatVFS::set_fsid(const char* value, size_t size) { + set_has_fsid(); + if (fsid_ == &::google::protobuf::internal::kEmptyString) { + fsid_ = new ::std::string; + } + fsid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* StatVFS::mutable_fsid() { + set_has_fsid(); + if (fsid_ == &::google::protobuf::internal::kEmptyString) { + fsid_ = new ::std::string; + } + return fsid_; +} +inline ::std::string* StatVFS::release_fsid() { + clear_has_fsid(); + if (fsid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = fsid_; + fsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void StatVFS::set_allocated_fsid(::std::string* fsid) { + if (fsid_ != &::google::protobuf::internal::kEmptyString) { + delete fsid_; + } + if (fsid) { + set_has_fsid(); + fsid_ = fsid; + } else { + clear_has_fsid(); + fsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 namemax = 5; +inline bool StatVFS::has_namemax() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void StatVFS::set_has_namemax() { + _has_bits_[0] |= 0x00000020u; +} +inline void StatVFS::clear_has_namemax() { + _has_bits_[0] &= ~0x00000020u; +} +inline void StatVFS::clear_namemax() { + namemax_ = 0u; + clear_has_namemax(); +} +inline ::google::protobuf::uint32 StatVFS::namemax() const { + return namemax_; +} +inline void StatVFS::set_namemax(::google::protobuf::uint32 value) { + set_has_namemax(); + namemax_ = value; +} + +// required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6; +inline bool StatVFS::has_access_control_policy() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void StatVFS::set_has_access_control_policy() { + _has_bits_[0] |= 0x00000040u; +} +inline void StatVFS::clear_has_access_control_policy() { + _has_bits_[0] &= ~0x00000040u; +} +inline void StatVFS::clear_access_control_policy() { + access_control_policy_ = 1; + clear_has_access_control_policy(); +} +inline ::xtreemfs::pbrpc::AccessControlPolicyType StatVFS::access_control_policy() const { + return static_cast< ::xtreemfs::pbrpc::AccessControlPolicyType >(access_control_policy_); +} +inline void StatVFS::set_access_control_policy(::xtreemfs::pbrpc::AccessControlPolicyType value) { + assert(::xtreemfs::pbrpc::AccessControlPolicyType_IsValid(value)); + set_has_access_control_policy(); + access_control_policy_ = value; +} + +// required .xtreemfs.pbrpc.StripingPolicy default_striping_policy = 7; +inline bool StatVFS::has_default_striping_policy() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void StatVFS::set_has_default_striping_policy() { + _has_bits_[0] |= 0x00000080u; +} +inline void StatVFS::clear_has_default_striping_policy() { + _has_bits_[0] &= ~0x00000080u; +} +inline void StatVFS::clear_default_striping_policy() { + if (default_striping_policy_ != NULL) default_striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear(); + clear_has_default_striping_policy(); +} +inline const ::xtreemfs::pbrpc::StripingPolicy& StatVFS::default_striping_policy() const { + return default_striping_policy_ != NULL ? *default_striping_policy_ : *default_instance_->default_striping_policy_; +} +inline ::xtreemfs::pbrpc::StripingPolicy* StatVFS::mutable_default_striping_policy() { + set_has_default_striping_policy(); + if (default_striping_policy_ == NULL) default_striping_policy_ = new ::xtreemfs::pbrpc::StripingPolicy; + return default_striping_policy_; +} +inline ::xtreemfs::pbrpc::StripingPolicy* StatVFS::release_default_striping_policy() { + clear_has_default_striping_policy(); + ::xtreemfs::pbrpc::StripingPolicy* temp = default_striping_policy_; + default_striping_policy_ = NULL; + return temp; +} +inline void StatVFS::set_allocated_default_striping_policy(::xtreemfs::pbrpc::StripingPolicy* default_striping_policy) { + delete default_striping_policy_; + default_striping_policy_ = default_striping_policy; + if (default_striping_policy) { + set_has_default_striping_policy(); + } else { + clear_has_default_striping_policy(); + } +} + +// required fixed64 etag = 8; +inline bool StatVFS::has_etag() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void StatVFS::set_has_etag() { + _has_bits_[0] |= 0x00000100u; +} +inline void StatVFS::clear_has_etag() { + _has_bits_[0] &= ~0x00000100u; +} +inline void StatVFS::clear_etag() { + etag_ = GOOGLE_ULONGLONG(0); + clear_has_etag(); +} +inline ::google::protobuf::uint64 StatVFS::etag() const { + return etag_; +} +inline void StatVFS::set_etag(::google::protobuf::uint64 value) { + set_has_etag(); + etag_ = value; +} + +// required fixed32 mode = 9; +inline bool StatVFS::has_mode() const { + return (_has_bits_[0] & 0x00000200u) != 0; +} +inline void StatVFS::set_has_mode() { + _has_bits_[0] |= 0x00000200u; +} +inline void StatVFS::clear_has_mode() { + _has_bits_[0] &= ~0x00000200u; +} +inline void StatVFS::clear_mode() { + mode_ = 0u; + clear_has_mode(); +} +inline ::google::protobuf::uint32 StatVFS::mode() const { + return mode_; +} +inline void StatVFS::set_mode(::google::protobuf::uint32 value) { + set_has_mode(); + mode_ = value; +} + +// required string name = 10; +inline bool StatVFS::has_name() const { + return (_has_bits_[0] & 0x00000400u) != 0; +} +inline void StatVFS::set_has_name() { + _has_bits_[0] |= 0x00000400u; +} +inline void StatVFS::clear_has_name() { + _has_bits_[0] &= ~0x00000400u; +} +inline void StatVFS::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& StatVFS::name() const { + return *name_; +} +inline void StatVFS::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void StatVFS::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void StatVFS::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* StatVFS::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* StatVFS::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void StatVFS::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string owner_group_id = 11; +inline bool StatVFS::has_owner_group_id() const { + return (_has_bits_[0] & 0x00000800u) != 0; +} +inline void StatVFS::set_has_owner_group_id() { + _has_bits_[0] |= 0x00000800u; +} +inline void StatVFS::clear_has_owner_group_id() { + _has_bits_[0] &= ~0x00000800u; +} +inline void StatVFS::clear_owner_group_id() { + if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) { + owner_group_id_->clear(); + } + clear_has_owner_group_id(); +} +inline const ::std::string& StatVFS::owner_group_id() const { + return *owner_group_id_; +} +inline void StatVFS::set_owner_group_id(const ::std::string& value) { + set_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + owner_group_id_ = new ::std::string; + } + owner_group_id_->assign(value); +} +inline void StatVFS::set_owner_group_id(const char* value) { + set_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + owner_group_id_ = new ::std::string; + } + owner_group_id_->assign(value); +} +inline void StatVFS::set_owner_group_id(const char* value, size_t size) { + set_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + owner_group_id_ = new ::std::string; + } + owner_group_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* StatVFS::mutable_owner_group_id() { + set_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + owner_group_id_ = new ::std::string; + } + return owner_group_id_; +} +inline ::std::string* StatVFS::release_owner_group_id() { + clear_has_owner_group_id(); + if (owner_group_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = owner_group_id_; + owner_group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void StatVFS::set_allocated_owner_group_id(::std::string* owner_group_id) { + if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) { + delete owner_group_id_; + } + if (owner_group_id) { + set_has_owner_group_id(); + owner_group_id_ = owner_group_id; + } else { + clear_has_owner_group_id(); + owner_group_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string owner_user_id = 12; +inline bool StatVFS::has_owner_user_id() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void StatVFS::set_has_owner_user_id() { + _has_bits_[0] |= 0x00001000u; +} +inline void StatVFS::clear_has_owner_user_id() { + _has_bits_[0] &= ~0x00001000u; +} +inline void StatVFS::clear_owner_user_id() { + if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) { + owner_user_id_->clear(); + } + clear_has_owner_user_id(); +} +inline const ::std::string& StatVFS::owner_user_id() const { + return *owner_user_id_; +} +inline void StatVFS::set_owner_user_id(const ::std::string& value) { + set_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + owner_user_id_ = new ::std::string; + } + owner_user_id_->assign(value); +} +inline void StatVFS::set_owner_user_id(const char* value) { + set_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + owner_user_id_ = new ::std::string; + } + owner_user_id_->assign(value); +} +inline void StatVFS::set_owner_user_id(const char* value, size_t size) { + set_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + owner_user_id_ = new ::std::string; + } + owner_user_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* StatVFS::mutable_owner_user_id() { + set_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + owner_user_id_ = new ::std::string; + } + return owner_user_id_; +} +inline ::std::string* StatVFS::release_owner_user_id() { + clear_has_owner_user_id(); + if (owner_user_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = owner_user_id_; + owner_user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void StatVFS::set_allocated_owner_user_id(::std::string* owner_user_id) { + if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) { + delete owner_user_id_; + } + if (owner_user_id) { + set_has_owner_user_id(); + owner_user_id_ = owner_user_id; + } else { + clear_has_owner_user_id(); + owner_user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// fsetattrRequest + +// required .xtreemfs.pbrpc.Stat stbuf = 1; +inline bool fsetattrRequest::has_stbuf() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void fsetattrRequest::set_has_stbuf() { + _has_bits_[0] |= 0x00000001u; +} +inline void fsetattrRequest::clear_has_stbuf() { + _has_bits_[0] &= ~0x00000001u; +} +inline void fsetattrRequest::clear_stbuf() { + if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear(); + clear_has_stbuf(); +} +inline const ::xtreemfs::pbrpc::Stat& fsetattrRequest::stbuf() const { + return stbuf_ != NULL ? *stbuf_ : *default_instance_->stbuf_; +} +inline ::xtreemfs::pbrpc::Stat* fsetattrRequest::mutable_stbuf() { + set_has_stbuf(); + if (stbuf_ == NULL) stbuf_ = new ::xtreemfs::pbrpc::Stat; + return stbuf_; +} +inline ::xtreemfs::pbrpc::Stat* fsetattrRequest::release_stbuf() { + clear_has_stbuf(); + ::xtreemfs::pbrpc::Stat* temp = stbuf_; + stbuf_ = NULL; + return temp; +} +inline void fsetattrRequest::set_allocated_stbuf(::xtreemfs::pbrpc::Stat* stbuf) { + delete stbuf_; + stbuf_ = stbuf; + if (stbuf) { + set_has_stbuf(); + } else { + clear_has_stbuf(); + } +} + +// required fixed32 to_set = 2; +inline bool fsetattrRequest::has_to_set() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void fsetattrRequest::set_has_to_set() { + _has_bits_[0] |= 0x00000002u; +} +inline void fsetattrRequest::clear_has_to_set() { + _has_bits_[0] &= ~0x00000002u; +} +inline void fsetattrRequest::clear_to_set() { + to_set_ = 0u; + clear_has_to_set(); +} +inline ::google::protobuf::uint32 fsetattrRequest::to_set() const { + return to_set_; +} +inline void fsetattrRequest::set_to_set(::google::protobuf::uint32 value) { + set_has_to_set(); + to_set_ = value; +} + +// required .xtreemfs.pbrpc.XCap cap = 3; +inline bool fsetattrRequest::has_cap() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void fsetattrRequest::set_has_cap() { + _has_bits_[0] |= 0x00000004u; +} +inline void fsetattrRequest::clear_has_cap() { + _has_bits_[0] &= ~0x00000004u; +} +inline void fsetattrRequest::clear_cap() { + if (cap_ != NULL) cap_->::xtreemfs::pbrpc::XCap::Clear(); + clear_has_cap(); +} +inline const ::xtreemfs::pbrpc::XCap& fsetattrRequest::cap() const { + return cap_ != NULL ? *cap_ : *default_instance_->cap_; +} +inline ::xtreemfs::pbrpc::XCap* fsetattrRequest::mutable_cap() { + set_has_cap(); + if (cap_ == NULL) cap_ = new ::xtreemfs::pbrpc::XCap; + return cap_; +} +inline ::xtreemfs::pbrpc::XCap* fsetattrRequest::release_cap() { + clear_has_cap(); + ::xtreemfs::pbrpc::XCap* temp = cap_; + cap_ = NULL; + return temp; +} +inline void fsetattrRequest::set_allocated_cap(::xtreemfs::pbrpc::XCap* cap) { + delete cap_; + cap_ = cap; + if (cap) { + set_has_cap(); + } else { + clear_has_cap(); + } +} + +// ------------------------------------------------------------------- + +// getattrRequest + +// required string volume_name = 1; +inline bool getattrRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void getattrRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void getattrRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void getattrRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& getattrRequest::volume_name() const { + return *volume_name_; +} +inline void getattrRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void getattrRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void getattrRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* getattrRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* getattrRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void getattrRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool getattrRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void getattrRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void getattrRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void getattrRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& getattrRequest::path() const { + return *path_; +} +inline void getattrRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void getattrRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void getattrRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* getattrRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* getattrRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void getattrRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 known_etag = 3; +inline bool getattrRequest::has_known_etag() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void getattrRequest::set_has_known_etag() { + _has_bits_[0] |= 0x00000004u; +} +inline void getattrRequest::clear_has_known_etag() { + _has_bits_[0] &= ~0x00000004u; +} +inline void getattrRequest::clear_known_etag() { + known_etag_ = GOOGLE_ULONGLONG(0); + clear_has_known_etag(); +} +inline ::google::protobuf::uint64 getattrRequest::known_etag() const { + return known_etag_; +} +inline void getattrRequest::set_known_etag(::google::protobuf::uint64 value) { + set_has_known_etag(); + known_etag_ = value; +} + +// ------------------------------------------------------------------- + +// getattrResponse + +// optional .xtreemfs.pbrpc.Stat stbuf = 1; +inline bool getattrResponse::has_stbuf() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void getattrResponse::set_has_stbuf() { + _has_bits_[0] |= 0x00000001u; +} +inline void getattrResponse::clear_has_stbuf() { + _has_bits_[0] &= ~0x00000001u; +} +inline void getattrResponse::clear_stbuf() { + if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear(); + clear_has_stbuf(); +} +inline const ::xtreemfs::pbrpc::Stat& getattrResponse::stbuf() const { + return stbuf_ != NULL ? *stbuf_ : *default_instance_->stbuf_; +} +inline ::xtreemfs::pbrpc::Stat* getattrResponse::mutable_stbuf() { + set_has_stbuf(); + if (stbuf_ == NULL) stbuf_ = new ::xtreemfs::pbrpc::Stat; + return stbuf_; +} +inline ::xtreemfs::pbrpc::Stat* getattrResponse::release_stbuf() { + clear_has_stbuf(); + ::xtreemfs::pbrpc::Stat* temp = stbuf_; + stbuf_ = NULL; + return temp; +} +inline void getattrResponse::set_allocated_stbuf(::xtreemfs::pbrpc::Stat* stbuf) { + delete stbuf_; + stbuf_ = stbuf; + if (stbuf) { + set_has_stbuf(); + } else { + clear_has_stbuf(); + } +} + +// ------------------------------------------------------------------- + +// getxattrRequest + +// required string volume_name = 1; +inline bool getxattrRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void getxattrRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void getxattrRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void getxattrRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& getxattrRequest::volume_name() const { + return *volume_name_; +} +inline void getxattrRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void getxattrRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void getxattrRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* getxattrRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* getxattrRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void getxattrRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool getxattrRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void getxattrRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void getxattrRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void getxattrRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& getxattrRequest::path() const { + return *path_; +} +inline void getxattrRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void getxattrRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void getxattrRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* getxattrRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* getxattrRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void getxattrRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string name = 3; +inline bool getxattrRequest::has_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void getxattrRequest::set_has_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void getxattrRequest::clear_has_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void getxattrRequest::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& getxattrRequest::name() const { + return *name_; +} +inline void getxattrRequest::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void getxattrRequest::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void getxattrRequest::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* getxattrRequest::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* getxattrRequest::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void getxattrRequest::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// getxattrResponse + +// required string value = 1; +inline bool getxattrResponse::has_value() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void getxattrResponse::set_has_value() { + _has_bits_[0] |= 0x00000001u; +} +inline void getxattrResponse::clear_has_value() { + _has_bits_[0] &= ~0x00000001u; +} +inline void getxattrResponse::clear_value() { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + clear_has_value(); +} +inline const ::std::string& getxattrResponse::value() const { + return *value_; +} +inline void getxattrResponse::set_value(const ::std::string& value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void getxattrResponse::set_value(const char* value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void getxattrResponse::set_value(const char* value, size_t size) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(reinterpret_cast(value), size); +} +inline ::std::string* getxattrResponse::mutable_value() { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + return value_; +} +inline ::std::string* getxattrResponse::release_value() { + clear_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = value_; + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void getxattrResponse::set_allocated_value(::std::string* value) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (value) { + set_has_value(); + value_ = value; + } else { + clear_has_value(); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional bytes value_bytes_string = 2; +inline bool getxattrResponse::has_value_bytes_string() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void getxattrResponse::set_has_value_bytes_string() { + _has_bits_[0] |= 0x00000002u; +} +inline void getxattrResponse::clear_has_value_bytes_string() { + _has_bits_[0] &= ~0x00000002u; +} +inline void getxattrResponse::clear_value_bytes_string() { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + value_bytes_string_->clear(); + } + clear_has_value_bytes_string(); +} +inline const ::std::string& getxattrResponse::value_bytes_string() const { + return *value_bytes_string_; +} +inline void getxattrResponse::set_value_bytes_string(const ::std::string& value) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(value); +} +inline void getxattrResponse::set_value_bytes_string(const char* value) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(value); +} +inline void getxattrResponse::set_value_bytes_string(const void* value, size_t size) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(reinterpret_cast(value), size); +} +inline ::std::string* getxattrResponse::mutable_value_bytes_string() { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + return value_bytes_string_; +} +inline ::std::string* getxattrResponse::release_value_bytes_string() { + clear_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = value_bytes_string_; + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void getxattrResponse::set_allocated_value_bytes_string(::std::string* value_bytes_string) { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + delete value_bytes_string_; + } + if (value_bytes_string) { + set_has_value_bytes_string(); + value_bytes_string_ = value_bytes_string; + } else { + clear_has_value_bytes_string(); + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// linkRequest + +// required string volume_name = 1; +inline bool linkRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void linkRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void linkRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void linkRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& linkRequest::volume_name() const { + return *volume_name_; +} +inline void linkRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void linkRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void linkRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* linkRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* linkRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void linkRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string target_path = 2; +inline bool linkRequest::has_target_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void linkRequest::set_has_target_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void linkRequest::clear_has_target_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void linkRequest::clear_target_path() { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + target_path_->clear(); + } + clear_has_target_path(); +} +inline const ::std::string& linkRequest::target_path() const { + return *target_path_; +} +inline void linkRequest::set_target_path(const ::std::string& value) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(value); +} +inline void linkRequest::set_target_path(const char* value) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(value); +} +inline void linkRequest::set_target_path(const char* value, size_t size) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* linkRequest::mutable_target_path() { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + return target_path_; +} +inline ::std::string* linkRequest::release_target_path() { + clear_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = target_path_; + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void linkRequest::set_allocated_target_path(::std::string* target_path) { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + delete target_path_; + } + if (target_path) { + set_has_target_path(); + target_path_ = target_path; + } else { + clear_has_target_path(); + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string link_path = 3; +inline bool linkRequest::has_link_path() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void linkRequest::set_has_link_path() { + _has_bits_[0] |= 0x00000004u; +} +inline void linkRequest::clear_has_link_path() { + _has_bits_[0] &= ~0x00000004u; +} +inline void linkRequest::clear_link_path() { + if (link_path_ != &::google::protobuf::internal::kEmptyString) { + link_path_->clear(); + } + clear_has_link_path(); +} +inline const ::std::string& linkRequest::link_path() const { + return *link_path_; +} +inline void linkRequest::set_link_path(const ::std::string& value) { + set_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + link_path_ = new ::std::string; + } + link_path_->assign(value); +} +inline void linkRequest::set_link_path(const char* value) { + set_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + link_path_ = new ::std::string; + } + link_path_->assign(value); +} +inline void linkRequest::set_link_path(const char* value, size_t size) { + set_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + link_path_ = new ::std::string; + } + link_path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* linkRequest::mutable_link_path() { + set_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + link_path_ = new ::std::string; + } + return link_path_; +} +inline ::std::string* linkRequest::release_link_path() { + clear_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = link_path_; + link_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void linkRequest::set_allocated_link_path(::std::string* link_path) { + if (link_path_ != &::google::protobuf::internal::kEmptyString) { + delete link_path_; + } + if (link_path) { + set_has_link_path(); + link_path_ = link_path; + } else { + clear_has_link_path(); + link_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// listxattrRequest + +// required string volume_name = 1; +inline bool listxattrRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void listxattrRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void listxattrRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void listxattrRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& listxattrRequest::volume_name() const { + return *volume_name_; +} +inline void listxattrRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void listxattrRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void listxattrRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* listxattrRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* listxattrRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void listxattrRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool listxattrRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void listxattrRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void listxattrRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void listxattrRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& listxattrRequest::path() const { + return *path_; +} +inline void listxattrRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void listxattrRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void listxattrRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* listxattrRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* listxattrRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void listxattrRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required bool names_only = 3; +inline bool listxattrRequest::has_names_only() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void listxattrRequest::set_has_names_only() { + _has_bits_[0] |= 0x00000004u; +} +inline void listxattrRequest::clear_has_names_only() { + _has_bits_[0] &= ~0x00000004u; +} +inline void listxattrRequest::clear_names_only() { + names_only_ = false; + clear_has_names_only(); +} +inline bool listxattrRequest::names_only() const { + return names_only_; +} +inline void listxattrRequest::set_names_only(bool value) { + set_has_names_only(); + names_only_ = value; +} + +// ------------------------------------------------------------------- + +// listxattrResponse + +// repeated .xtreemfs.pbrpc.XAttr xattrs = 1; +inline int listxattrResponse::xattrs_size() const { + return xattrs_.size(); +} +inline void listxattrResponse::clear_xattrs() { + xattrs_.Clear(); +} +inline const ::xtreemfs::pbrpc::XAttr& listxattrResponse::xattrs(int index) const { + return xattrs_.Get(index); +} +inline ::xtreemfs::pbrpc::XAttr* listxattrResponse::mutable_xattrs(int index) { + return xattrs_.Mutable(index); +} +inline ::xtreemfs::pbrpc::XAttr* listxattrResponse::add_xattrs() { + return xattrs_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::XAttr >& +listxattrResponse::xattrs() const { + return xattrs_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::XAttr >* +listxattrResponse::mutable_xattrs() { + return &xattrs_; +} + +// ------------------------------------------------------------------- + +// mkdirRequest + +// required string volume_name = 1; +inline bool mkdirRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void mkdirRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void mkdirRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void mkdirRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& mkdirRequest::volume_name() const { + return *volume_name_; +} +inline void mkdirRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void mkdirRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void mkdirRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* mkdirRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* mkdirRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void mkdirRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool mkdirRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void mkdirRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void mkdirRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void mkdirRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& mkdirRequest::path() const { + return *path_; +} +inline void mkdirRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void mkdirRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void mkdirRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* mkdirRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* mkdirRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void mkdirRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 mode = 3; +inline bool mkdirRequest::has_mode() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void mkdirRequest::set_has_mode() { + _has_bits_[0] |= 0x00000004u; +} +inline void mkdirRequest::clear_has_mode() { + _has_bits_[0] &= ~0x00000004u; +} +inline void mkdirRequest::clear_mode() { + mode_ = 0u; + clear_has_mode(); +} +inline ::google::protobuf::uint32 mkdirRequest::mode() const { + return mode_; +} +inline void mkdirRequest::set_mode(::google::protobuf::uint32 value) { + set_has_mode(); + mode_ = value; +} + +// ------------------------------------------------------------------- + +// openRequest + +// required string volume_name = 1; +inline bool openRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void openRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void openRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void openRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& openRequest::volume_name() const { + return *volume_name_; +} +inline void openRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void openRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void openRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* openRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* openRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void openRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool openRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void openRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void openRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void openRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& openRequest::path() const { + return *path_; +} +inline void openRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void openRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void openRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* openRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* openRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void openRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 flags = 3; +inline bool openRequest::has_flags() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void openRequest::set_has_flags() { + _has_bits_[0] |= 0x00000004u; +} +inline void openRequest::clear_has_flags() { + _has_bits_[0] &= ~0x00000004u; +} +inline void openRequest::clear_flags() { + flags_ = 0u; + clear_has_flags(); +} +inline ::google::protobuf::uint32 openRequest::flags() const { + return flags_; +} +inline void openRequest::set_flags(::google::protobuf::uint32 value) { + set_has_flags(); + flags_ = value; +} + +// required fixed32 mode = 4; +inline bool openRequest::has_mode() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void openRequest::set_has_mode() { + _has_bits_[0] |= 0x00000008u; +} +inline void openRequest::clear_has_mode() { + _has_bits_[0] &= ~0x00000008u; +} +inline void openRequest::clear_mode() { + mode_ = 0u; + clear_has_mode(); +} +inline ::google::protobuf::uint32 openRequest::mode() const { + return mode_; +} +inline void openRequest::set_mode(::google::protobuf::uint32 value) { + set_has_mode(); + mode_ = value; +} + +// required fixed32 attributes = 5; +inline bool openRequest::has_attributes() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void openRequest::set_has_attributes() { + _has_bits_[0] |= 0x00000010u; +} +inline void openRequest::clear_has_attributes() { + _has_bits_[0] &= ~0x00000010u; +} +inline void openRequest::clear_attributes() { + attributes_ = 0u; + clear_has_attributes(); +} +inline ::google::protobuf::uint32 openRequest::attributes() const { + return attributes_; +} +inline void openRequest::set_attributes(::google::protobuf::uint32 value) { + set_has_attributes(); + attributes_ = value; +} + +// optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6; +inline bool openRequest::has_coordinates() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void openRequest::set_has_coordinates() { + _has_bits_[0] |= 0x00000020u; +} +inline void openRequest::clear_has_coordinates() { + _has_bits_[0] &= ~0x00000020u; +} +inline void openRequest::clear_coordinates() { + if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear(); + clear_has_coordinates(); +} +inline const ::xtreemfs::pbrpc::VivaldiCoordinates& openRequest::coordinates() const { + return coordinates_ != NULL ? *coordinates_ : *default_instance_->coordinates_; +} +inline ::xtreemfs::pbrpc::VivaldiCoordinates* openRequest::mutable_coordinates() { + set_has_coordinates(); + if (coordinates_ == NULL) coordinates_ = new ::xtreemfs::pbrpc::VivaldiCoordinates; + return coordinates_; +} +inline ::xtreemfs::pbrpc::VivaldiCoordinates* openRequest::release_coordinates() { + clear_has_coordinates(); + ::xtreemfs::pbrpc::VivaldiCoordinates* temp = coordinates_; + coordinates_ = NULL; + return temp; +} +inline void openRequest::set_allocated_coordinates(::xtreemfs::pbrpc::VivaldiCoordinates* coordinates) { + delete coordinates_; + coordinates_ = coordinates; + if (coordinates) { + set_has_coordinates(); + } else { + clear_has_coordinates(); + } +} + +// ------------------------------------------------------------------- + +// openResponse + +// required .xtreemfs.pbrpc.FileCredentials creds = 1; +inline bool openResponse::has_creds() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void openResponse::set_has_creds() { + _has_bits_[0] |= 0x00000001u; +} +inline void openResponse::clear_has_creds() { + _has_bits_[0] &= ~0x00000001u; +} +inline void openResponse::clear_creds() { + if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_creds(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& openResponse::creds() const { + return creds_ != NULL ? *creds_ : *default_instance_->creds_; +} +inline ::xtreemfs::pbrpc::FileCredentials* openResponse::mutable_creds() { + set_has_creds(); + if (creds_ == NULL) creds_ = new ::xtreemfs::pbrpc::FileCredentials; + return creds_; +} +inline ::xtreemfs::pbrpc::FileCredentials* openResponse::release_creds() { + clear_has_creds(); + ::xtreemfs::pbrpc::FileCredentials* temp = creds_; + creds_ = NULL; + return temp; +} +inline void openResponse::set_allocated_creds(::xtreemfs::pbrpc::FileCredentials* creds) { + delete creds_; + creds_ = creds; + if (creds) { + set_has_creds(); + } else { + clear_has_creds(); + } +} + +// required fixed32 timestamp_s = 2; +inline bool openResponse::has_timestamp_s() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void openResponse::set_has_timestamp_s() { + _has_bits_[0] |= 0x00000002u; +} +inline void openResponse::clear_has_timestamp_s() { + _has_bits_[0] &= ~0x00000002u; +} +inline void openResponse::clear_timestamp_s() { + timestamp_s_ = 0u; + clear_has_timestamp_s(); +} +inline ::google::protobuf::uint32 openResponse::timestamp_s() const { + return timestamp_s_; +} +inline void openResponse::set_timestamp_s(::google::protobuf::uint32 value) { + set_has_timestamp_s(); + timestamp_s_ = value; +} + +// ------------------------------------------------------------------- + +// readdirRequest + +// required string volume_name = 1; +inline bool readdirRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void readdirRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void readdirRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void readdirRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& readdirRequest::volume_name() const { + return *volume_name_; +} +inline void readdirRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void readdirRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void readdirRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* readdirRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* readdirRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void readdirRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool readdirRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void readdirRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void readdirRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void readdirRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& readdirRequest::path() const { + return *path_; +} +inline void readdirRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void readdirRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void readdirRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* readdirRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* readdirRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void readdirRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 known_etag = 3; +inline bool readdirRequest::has_known_etag() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void readdirRequest::set_has_known_etag() { + _has_bits_[0] |= 0x00000004u; +} +inline void readdirRequest::clear_has_known_etag() { + _has_bits_[0] &= ~0x00000004u; +} +inline void readdirRequest::clear_known_etag() { + known_etag_ = GOOGLE_ULONGLONG(0); + clear_has_known_etag(); +} +inline ::google::protobuf::uint64 readdirRequest::known_etag() const { + return known_etag_; +} +inline void readdirRequest::set_known_etag(::google::protobuf::uint64 value) { + set_has_known_etag(); + known_etag_ = value; +} + +// required fixed32 limit_directory_entries_count = 4; +inline bool readdirRequest::has_limit_directory_entries_count() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void readdirRequest::set_has_limit_directory_entries_count() { + _has_bits_[0] |= 0x00000008u; +} +inline void readdirRequest::clear_has_limit_directory_entries_count() { + _has_bits_[0] &= ~0x00000008u; +} +inline void readdirRequest::clear_limit_directory_entries_count() { + limit_directory_entries_count_ = 0u; + clear_has_limit_directory_entries_count(); +} +inline ::google::protobuf::uint32 readdirRequest::limit_directory_entries_count() const { + return limit_directory_entries_count_; +} +inline void readdirRequest::set_limit_directory_entries_count(::google::protobuf::uint32 value) { + set_has_limit_directory_entries_count(); + limit_directory_entries_count_ = value; +} + +// required bool names_only = 5; +inline bool readdirRequest::has_names_only() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void readdirRequest::set_has_names_only() { + _has_bits_[0] |= 0x00000010u; +} +inline void readdirRequest::clear_has_names_only() { + _has_bits_[0] &= ~0x00000010u; +} +inline void readdirRequest::clear_names_only() { + names_only_ = false; + clear_has_names_only(); +} +inline bool readdirRequest::names_only() const { + return names_only_; +} +inline void readdirRequest::set_names_only(bool value) { + set_has_names_only(); + names_only_ = value; +} + +// required fixed64 seen_directory_entries_count = 6; +inline bool readdirRequest::has_seen_directory_entries_count() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void readdirRequest::set_has_seen_directory_entries_count() { + _has_bits_[0] |= 0x00000020u; +} +inline void readdirRequest::clear_has_seen_directory_entries_count() { + _has_bits_[0] &= ~0x00000020u; +} +inline void readdirRequest::clear_seen_directory_entries_count() { + seen_directory_entries_count_ = GOOGLE_ULONGLONG(0); + clear_has_seen_directory_entries_count(); +} +inline ::google::protobuf::uint64 readdirRequest::seen_directory_entries_count() const { + return seen_directory_entries_count_; +} +inline void readdirRequest::set_seen_directory_entries_count(::google::protobuf::uint64 value) { + set_has_seen_directory_entries_count(); + seen_directory_entries_count_ = value; +} + +// ------------------------------------------------------------------- + +// readlinkRequest + +// required string volume_name = 1; +inline bool readlinkRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void readlinkRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void readlinkRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void readlinkRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& readlinkRequest::volume_name() const { + return *volume_name_; +} +inline void readlinkRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void readlinkRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void readlinkRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* readlinkRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* readlinkRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void readlinkRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool readlinkRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void readlinkRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void readlinkRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void readlinkRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& readlinkRequest::path() const { + return *path_; +} +inline void readlinkRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void readlinkRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void readlinkRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* readlinkRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* readlinkRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void readlinkRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// readlinkResponse + +// repeated string link_target_path = 1; +inline int readlinkResponse::link_target_path_size() const { + return link_target_path_.size(); +} +inline void readlinkResponse::clear_link_target_path() { + link_target_path_.Clear(); +} +inline const ::std::string& readlinkResponse::link_target_path(int index) const { + return link_target_path_.Get(index); +} +inline ::std::string* readlinkResponse::mutable_link_target_path(int index) { + return link_target_path_.Mutable(index); +} +inline void readlinkResponse::set_link_target_path(int index, const ::std::string& value) { + link_target_path_.Mutable(index)->assign(value); +} +inline void readlinkResponse::set_link_target_path(int index, const char* value) { + link_target_path_.Mutable(index)->assign(value); +} +inline void readlinkResponse::set_link_target_path(int index, const char* value, size_t size) { + link_target_path_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* readlinkResponse::add_link_target_path() { + return link_target_path_.Add(); +} +inline void readlinkResponse::add_link_target_path(const ::std::string& value) { + link_target_path_.Add()->assign(value); +} +inline void readlinkResponse::add_link_target_path(const char* value) { + link_target_path_.Add()->assign(value); +} +inline void readlinkResponse::add_link_target_path(const char* value, size_t size) { + link_target_path_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +readlinkResponse::link_target_path() const { + return link_target_path_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +readlinkResponse::mutable_link_target_path() { + return &link_target_path_; +} + +// ------------------------------------------------------------------- + +// removexattrRequest + +// required string volume_name = 1; +inline bool removexattrRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void removexattrRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void removexattrRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void removexattrRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& removexattrRequest::volume_name() const { + return *volume_name_; +} +inline void removexattrRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void removexattrRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void removexattrRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* removexattrRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* removexattrRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void removexattrRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool removexattrRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void removexattrRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void removexattrRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void removexattrRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& removexattrRequest::path() const { + return *path_; +} +inline void removexattrRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void removexattrRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void removexattrRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* removexattrRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* removexattrRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void removexattrRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string name = 3; +inline bool removexattrRequest::has_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void removexattrRequest::set_has_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void removexattrRequest::clear_has_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void removexattrRequest::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& removexattrRequest::name() const { + return *name_; +} +inline void removexattrRequest::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void removexattrRequest::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void removexattrRequest::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* removexattrRequest::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* removexattrRequest::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void removexattrRequest::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// renameRequest + +// required string volume_name = 1; +inline bool renameRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void renameRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void renameRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void renameRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& renameRequest::volume_name() const { + return *volume_name_; +} +inline void renameRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void renameRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void renameRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* renameRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* renameRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void renameRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string source_path = 2; +inline bool renameRequest::has_source_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void renameRequest::set_has_source_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void renameRequest::clear_has_source_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void renameRequest::clear_source_path() { + if (source_path_ != &::google::protobuf::internal::kEmptyString) { + source_path_->clear(); + } + clear_has_source_path(); +} +inline const ::std::string& renameRequest::source_path() const { + return *source_path_; +} +inline void renameRequest::set_source_path(const ::std::string& value) { + set_has_source_path(); + if (source_path_ == &::google::protobuf::internal::kEmptyString) { + source_path_ = new ::std::string; + } + source_path_->assign(value); +} +inline void renameRequest::set_source_path(const char* value) { + set_has_source_path(); + if (source_path_ == &::google::protobuf::internal::kEmptyString) { + source_path_ = new ::std::string; + } + source_path_->assign(value); +} +inline void renameRequest::set_source_path(const char* value, size_t size) { + set_has_source_path(); + if (source_path_ == &::google::protobuf::internal::kEmptyString) { + source_path_ = new ::std::string; + } + source_path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* renameRequest::mutable_source_path() { + set_has_source_path(); + if (source_path_ == &::google::protobuf::internal::kEmptyString) { + source_path_ = new ::std::string; + } + return source_path_; +} +inline ::std::string* renameRequest::release_source_path() { + clear_has_source_path(); + if (source_path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = source_path_; + source_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void renameRequest::set_allocated_source_path(::std::string* source_path) { + if (source_path_ != &::google::protobuf::internal::kEmptyString) { + delete source_path_; + } + if (source_path) { + set_has_source_path(); + source_path_ = source_path; + } else { + clear_has_source_path(); + source_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string target_path = 3; +inline bool renameRequest::has_target_path() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void renameRequest::set_has_target_path() { + _has_bits_[0] |= 0x00000004u; +} +inline void renameRequest::clear_has_target_path() { + _has_bits_[0] &= ~0x00000004u; +} +inline void renameRequest::clear_target_path() { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + target_path_->clear(); + } + clear_has_target_path(); +} +inline const ::std::string& renameRequest::target_path() const { + return *target_path_; +} +inline void renameRequest::set_target_path(const ::std::string& value) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(value); +} +inline void renameRequest::set_target_path(const char* value) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(value); +} +inline void renameRequest::set_target_path(const char* value, size_t size) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* renameRequest::mutable_target_path() { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + return target_path_; +} +inline ::std::string* renameRequest::release_target_path() { + clear_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = target_path_; + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void renameRequest::set_allocated_target_path(::std::string* target_path) { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + delete target_path_; + } + if (target_path) { + set_has_target_path(); + target_path_ = target_path; + } else { + clear_has_target_path(); + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// renameResponse + +// required fixed32 timestamp_s = 1; +inline bool renameResponse::has_timestamp_s() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void renameResponse::set_has_timestamp_s() { + _has_bits_[0] |= 0x00000001u; +} +inline void renameResponse::clear_has_timestamp_s() { + _has_bits_[0] &= ~0x00000001u; +} +inline void renameResponse::clear_timestamp_s() { + timestamp_s_ = 0u; + clear_has_timestamp_s(); +} +inline ::google::protobuf::uint32 renameResponse::timestamp_s() const { + return timestamp_s_; +} +inline void renameResponse::set_timestamp_s(::google::protobuf::uint32 value) { + set_has_timestamp_s(); + timestamp_s_ = value; +} + +// optional .xtreemfs.pbrpc.FileCredentials creds = 2; +inline bool renameResponse::has_creds() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void renameResponse::set_has_creds() { + _has_bits_[0] |= 0x00000002u; +} +inline void renameResponse::clear_has_creds() { + _has_bits_[0] &= ~0x00000002u; +} +inline void renameResponse::clear_creds() { + if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_creds(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& renameResponse::creds() const { + return creds_ != NULL ? *creds_ : *default_instance_->creds_; +} +inline ::xtreemfs::pbrpc::FileCredentials* renameResponse::mutable_creds() { + set_has_creds(); + if (creds_ == NULL) creds_ = new ::xtreemfs::pbrpc::FileCredentials; + return creds_; +} +inline ::xtreemfs::pbrpc::FileCredentials* renameResponse::release_creds() { + clear_has_creds(); + ::xtreemfs::pbrpc::FileCredentials* temp = creds_; + creds_ = NULL; + return temp; +} +inline void renameResponse::set_allocated_creds(::xtreemfs::pbrpc::FileCredentials* creds) { + delete creds_; + creds_ = creds; + if (creds) { + set_has_creds(); + } else { + clear_has_creds(); + } +} + +// ------------------------------------------------------------------- + +// rmdirRequest + +// required string volume_name = 1; +inline bool rmdirRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void rmdirRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void rmdirRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void rmdirRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& rmdirRequest::volume_name() const { + return *volume_name_; +} +inline void rmdirRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void rmdirRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void rmdirRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* rmdirRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* rmdirRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void rmdirRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool rmdirRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void rmdirRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void rmdirRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void rmdirRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& rmdirRequest::path() const { + return *path_; +} +inline void rmdirRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void rmdirRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void rmdirRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* rmdirRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* rmdirRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void rmdirRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// setattrRequest + +// required string volume_name = 1; +inline bool setattrRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void setattrRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void setattrRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void setattrRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& setattrRequest::volume_name() const { + return *volume_name_; +} +inline void setattrRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void setattrRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void setattrRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* setattrRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* setattrRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void setattrRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool setattrRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void setattrRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void setattrRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void setattrRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& setattrRequest::path() const { + return *path_; +} +inline void setattrRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void setattrRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void setattrRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* setattrRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* setattrRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void setattrRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required .xtreemfs.pbrpc.Stat stbuf = 3; +inline bool setattrRequest::has_stbuf() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void setattrRequest::set_has_stbuf() { + _has_bits_[0] |= 0x00000004u; +} +inline void setattrRequest::clear_has_stbuf() { + _has_bits_[0] &= ~0x00000004u; +} +inline void setattrRequest::clear_stbuf() { + if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear(); + clear_has_stbuf(); +} +inline const ::xtreemfs::pbrpc::Stat& setattrRequest::stbuf() const { + return stbuf_ != NULL ? *stbuf_ : *default_instance_->stbuf_; +} +inline ::xtreemfs::pbrpc::Stat* setattrRequest::mutable_stbuf() { + set_has_stbuf(); + if (stbuf_ == NULL) stbuf_ = new ::xtreemfs::pbrpc::Stat; + return stbuf_; +} +inline ::xtreemfs::pbrpc::Stat* setattrRequest::release_stbuf() { + clear_has_stbuf(); + ::xtreemfs::pbrpc::Stat* temp = stbuf_; + stbuf_ = NULL; + return temp; +} +inline void setattrRequest::set_allocated_stbuf(::xtreemfs::pbrpc::Stat* stbuf) { + delete stbuf_; + stbuf_ = stbuf; + if (stbuf) { + set_has_stbuf(); + } else { + clear_has_stbuf(); + } +} + +// required fixed32 to_set = 4; +inline bool setattrRequest::has_to_set() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void setattrRequest::set_has_to_set() { + _has_bits_[0] |= 0x00000008u; +} +inline void setattrRequest::clear_has_to_set() { + _has_bits_[0] &= ~0x00000008u; +} +inline void setattrRequest::clear_to_set() { + to_set_ = 0u; + clear_has_to_set(); +} +inline ::google::protobuf::uint32 setattrRequest::to_set() const { + return to_set_; +} +inline void setattrRequest::set_to_set(::google::protobuf::uint32 value) { + set_has_to_set(); + to_set_ = value; +} + +// ------------------------------------------------------------------- + +// setxattrRequest + +// required string volume_name = 1; +inline bool setxattrRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void setxattrRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void setxattrRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void setxattrRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& setxattrRequest::volume_name() const { + return *volume_name_; +} +inline void setxattrRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void setxattrRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void setxattrRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* setxattrRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* setxattrRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void setxattrRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool setxattrRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void setxattrRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void setxattrRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void setxattrRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& setxattrRequest::path() const { + return *path_; +} +inline void setxattrRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void setxattrRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void setxattrRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* setxattrRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* setxattrRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void setxattrRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string name = 3; +inline bool setxattrRequest::has_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void setxattrRequest::set_has_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void setxattrRequest::clear_has_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void setxattrRequest::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& setxattrRequest::name() const { + return *name_; +} +inline void setxattrRequest::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void setxattrRequest::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void setxattrRequest::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* setxattrRequest::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* setxattrRequest::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void setxattrRequest::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string value = 4; +inline bool setxattrRequest::has_value() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void setxattrRequest::set_has_value() { + _has_bits_[0] |= 0x00000008u; +} +inline void setxattrRequest::clear_has_value() { + _has_bits_[0] &= ~0x00000008u; +} +inline void setxattrRequest::clear_value() { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + clear_has_value(); +} +inline const ::std::string& setxattrRequest::value() const { + return *value_; +} +inline void setxattrRequest::set_value(const ::std::string& value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void setxattrRequest::set_value(const char* value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void setxattrRequest::set_value(const char* value, size_t size) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(reinterpret_cast(value), size); +} +inline ::std::string* setxattrRequest::mutable_value() { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + return value_; +} +inline ::std::string* setxattrRequest::release_value() { + clear_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = value_; + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void setxattrRequest::set_allocated_value(::std::string* value) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (value) { + set_has_value(); + value_ = value; + } else { + clear_has_value(); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional bytes value_bytes_string = 6; +inline bool setxattrRequest::has_value_bytes_string() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void setxattrRequest::set_has_value_bytes_string() { + _has_bits_[0] |= 0x00000010u; +} +inline void setxattrRequest::clear_has_value_bytes_string() { + _has_bits_[0] &= ~0x00000010u; +} +inline void setxattrRequest::clear_value_bytes_string() { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + value_bytes_string_->clear(); + } + clear_has_value_bytes_string(); +} +inline const ::std::string& setxattrRequest::value_bytes_string() const { + return *value_bytes_string_; +} +inline void setxattrRequest::set_value_bytes_string(const ::std::string& value) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(value); +} +inline void setxattrRequest::set_value_bytes_string(const char* value) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(value); +} +inline void setxattrRequest::set_value_bytes_string(const void* value, size_t size) { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + value_bytes_string_->assign(reinterpret_cast(value), size); +} +inline ::std::string* setxattrRequest::mutable_value_bytes_string() { + set_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + value_bytes_string_ = new ::std::string; + } + return value_bytes_string_; +} +inline ::std::string* setxattrRequest::release_value_bytes_string() { + clear_has_value_bytes_string(); + if (value_bytes_string_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = value_bytes_string_; + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void setxattrRequest::set_allocated_value_bytes_string(::std::string* value_bytes_string) { + if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) { + delete value_bytes_string_; + } + if (value_bytes_string) { + set_has_value_bytes_string(); + value_bytes_string_ = value_bytes_string; + } else { + clear_has_value_bytes_string(); + value_bytes_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 flags = 5; +inline bool setxattrRequest::has_flags() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void setxattrRequest::set_has_flags() { + _has_bits_[0] |= 0x00000020u; +} +inline void setxattrRequest::clear_has_flags() { + _has_bits_[0] &= ~0x00000020u; +} +inline void setxattrRequest::clear_flags() { + flags_ = 0u; + clear_has_flags(); +} +inline ::google::protobuf::uint32 setxattrRequest::flags() const { + return flags_; +} +inline void setxattrRequest::set_flags(::google::protobuf::uint32 value) { + set_has_flags(); + flags_ = value; +} + +// ------------------------------------------------------------------- + +// statvfsRequest + +// required string volume_name = 1; +inline bool statvfsRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void statvfsRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void statvfsRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void statvfsRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& statvfsRequest::volume_name() const { + return *volume_name_; +} +inline void statvfsRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void statvfsRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void statvfsRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* statvfsRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* statvfsRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void statvfsRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 known_etag = 5; +inline bool statvfsRequest::has_known_etag() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void statvfsRequest::set_has_known_etag() { + _has_bits_[0] |= 0x00000002u; +} +inline void statvfsRequest::clear_has_known_etag() { + _has_bits_[0] &= ~0x00000002u; +} +inline void statvfsRequest::clear_known_etag() { + known_etag_ = GOOGLE_ULONGLONG(0); + clear_has_known_etag(); +} +inline ::google::protobuf::uint64 statvfsRequest::known_etag() const { + return known_etag_; +} +inline void statvfsRequest::set_known_etag(::google::protobuf::uint64 value) { + set_has_known_etag(); + known_etag_ = value; +} + +// ------------------------------------------------------------------- + +// symlinkRequest + +// required string volume_name = 1; +inline bool symlinkRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void symlinkRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void symlinkRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void symlinkRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& symlinkRequest::volume_name() const { + return *volume_name_; +} +inline void symlinkRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void symlinkRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void symlinkRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* symlinkRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* symlinkRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void symlinkRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string target_path = 2; +inline bool symlinkRequest::has_target_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void symlinkRequest::set_has_target_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void symlinkRequest::clear_has_target_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void symlinkRequest::clear_target_path() { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + target_path_->clear(); + } + clear_has_target_path(); +} +inline const ::std::string& symlinkRequest::target_path() const { + return *target_path_; +} +inline void symlinkRequest::set_target_path(const ::std::string& value) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(value); +} +inline void symlinkRequest::set_target_path(const char* value) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(value); +} +inline void symlinkRequest::set_target_path(const char* value, size_t size) { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + target_path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* symlinkRequest::mutable_target_path() { + set_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + target_path_ = new ::std::string; + } + return target_path_; +} +inline ::std::string* symlinkRequest::release_target_path() { + clear_has_target_path(); + if (target_path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = target_path_; + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void symlinkRequest::set_allocated_target_path(::std::string* target_path) { + if (target_path_ != &::google::protobuf::internal::kEmptyString) { + delete target_path_; + } + if (target_path) { + set_has_target_path(); + target_path_ = target_path; + } else { + clear_has_target_path(); + target_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string link_path = 3; +inline bool symlinkRequest::has_link_path() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void symlinkRequest::set_has_link_path() { + _has_bits_[0] |= 0x00000004u; +} +inline void symlinkRequest::clear_has_link_path() { + _has_bits_[0] &= ~0x00000004u; +} +inline void symlinkRequest::clear_link_path() { + if (link_path_ != &::google::protobuf::internal::kEmptyString) { + link_path_->clear(); + } + clear_has_link_path(); +} +inline const ::std::string& symlinkRequest::link_path() const { + return *link_path_; +} +inline void symlinkRequest::set_link_path(const ::std::string& value) { + set_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + link_path_ = new ::std::string; + } + link_path_->assign(value); +} +inline void symlinkRequest::set_link_path(const char* value) { + set_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + link_path_ = new ::std::string; + } + link_path_->assign(value); +} +inline void symlinkRequest::set_link_path(const char* value, size_t size) { + set_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + link_path_ = new ::std::string; + } + link_path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* symlinkRequest::mutable_link_path() { + set_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + link_path_ = new ::std::string; + } + return link_path_; +} +inline ::std::string* symlinkRequest::release_link_path() { + clear_has_link_path(); + if (link_path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = link_path_; + link_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void symlinkRequest::set_allocated_link_path(::std::string* link_path) { + if (link_path_ != &::google::protobuf::internal::kEmptyString) { + delete link_path_; + } + if (link_path) { + set_has_link_path(); + link_path_ = link_path; + } else { + clear_has_link_path(); + link_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// unlinkRequest + +// required string volume_name = 1; +inline bool unlinkRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void unlinkRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void unlinkRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void unlinkRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& unlinkRequest::volume_name() const { + return *volume_name_; +} +inline void unlinkRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void unlinkRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void unlinkRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* unlinkRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* unlinkRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void unlinkRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool unlinkRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void unlinkRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void unlinkRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void unlinkRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& unlinkRequest::path() const { + return *path_; +} +inline void unlinkRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void unlinkRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void unlinkRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* unlinkRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* unlinkRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void unlinkRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// unlinkResponse + +// required fixed32 timestamp_s = 1; +inline bool unlinkResponse::has_timestamp_s() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void unlinkResponse::set_has_timestamp_s() { + _has_bits_[0] |= 0x00000001u; +} +inline void unlinkResponse::clear_has_timestamp_s() { + _has_bits_[0] &= ~0x00000001u; +} +inline void unlinkResponse::clear_timestamp_s() { + timestamp_s_ = 0u; + clear_has_timestamp_s(); +} +inline ::google::protobuf::uint32 unlinkResponse::timestamp_s() const { + return timestamp_s_; +} +inline void unlinkResponse::set_timestamp_s(::google::protobuf::uint32 value) { + set_has_timestamp_s(); + timestamp_s_ = value; +} + +// optional .xtreemfs.pbrpc.FileCredentials creds = 2; +inline bool unlinkResponse::has_creds() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void unlinkResponse::set_has_creds() { + _has_bits_[0] |= 0x00000002u; +} +inline void unlinkResponse::clear_has_creds() { + _has_bits_[0] &= ~0x00000002u; +} +inline void unlinkResponse::clear_creds() { + if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_creds(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& unlinkResponse::creds() const { + return creds_ != NULL ? *creds_ : *default_instance_->creds_; +} +inline ::xtreemfs::pbrpc::FileCredentials* unlinkResponse::mutable_creds() { + set_has_creds(); + if (creds_ == NULL) creds_ = new ::xtreemfs::pbrpc::FileCredentials; + return creds_; +} +inline ::xtreemfs::pbrpc::FileCredentials* unlinkResponse::release_creds() { + clear_has_creds(); + ::xtreemfs::pbrpc::FileCredentials* temp = creds_; + creds_ = NULL; + return temp; +} +inline void unlinkResponse::set_allocated_creds(::xtreemfs::pbrpc::FileCredentials* creds) { + delete creds_; + creds_ = creds; + if (creds) { + set_has_creds(); + } else { + clear_has_creds(); + } +} + +// ------------------------------------------------------------------- + +// accessRequest + +// required string volume_name = 1; +inline bool accessRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void accessRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void accessRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void accessRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& accessRequest::volume_name() const { + return *volume_name_; +} +inline void accessRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void accessRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void accessRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* accessRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* accessRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void accessRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string path = 2; +inline bool accessRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void accessRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void accessRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void accessRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& accessRequest::path() const { + return *path_; +} +inline void accessRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void accessRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void accessRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* accessRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* accessRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void accessRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 flags = 3; +inline bool accessRequest::has_flags() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void accessRequest::set_has_flags() { + _has_bits_[0] |= 0x00000004u; +} +inline void accessRequest::clear_has_flags() { + _has_bits_[0] &= ~0x00000004u; +} +inline void accessRequest::clear_flags() { + flags_ = 0u; + clear_has_flags(); +} +inline ::google::protobuf::uint32 accessRequest::flags() const { + return flags_; +} +inline void accessRequest::set_flags(::google::protobuf::uint32 value) { + set_has_flags(); + flags_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_check_file_existsRequest + +// required string volume_id = 1; +inline bool xtreemfs_check_file_existsRequest::has_volume_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_check_file_existsRequest::set_has_volume_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_check_file_existsRequest::clear_has_volume_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_check_file_existsRequest::clear_volume_id() { + if (volume_id_ != &::google::protobuf::internal::kEmptyString) { + volume_id_->clear(); + } + clear_has_volume_id(); +} +inline const ::std::string& xtreemfs_check_file_existsRequest::volume_id() const { + return *volume_id_; +} +inline void xtreemfs_check_file_existsRequest::set_volume_id(const ::std::string& value) { + set_has_volume_id(); + if (volume_id_ == &::google::protobuf::internal::kEmptyString) { + volume_id_ = new ::std::string; + } + volume_id_->assign(value); +} +inline void xtreemfs_check_file_existsRequest::set_volume_id(const char* value) { + set_has_volume_id(); + if (volume_id_ == &::google::protobuf::internal::kEmptyString) { + volume_id_ = new ::std::string; + } + volume_id_->assign(value); +} +inline void xtreemfs_check_file_existsRequest::set_volume_id(const char* value, size_t size) { + set_has_volume_id(); + if (volume_id_ == &::google::protobuf::internal::kEmptyString) { + volume_id_ = new ::std::string; + } + volume_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_check_file_existsRequest::mutable_volume_id() { + set_has_volume_id(); + if (volume_id_ == &::google::protobuf::internal::kEmptyString) { + volume_id_ = new ::std::string; + } + return volume_id_; +} +inline ::std::string* xtreemfs_check_file_existsRequest::release_volume_id() { + clear_has_volume_id(); + if (volume_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_id_; + volume_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_check_file_existsRequest::set_allocated_volume_id(::std::string* volume_id) { + if (volume_id_ != &::google::protobuf::internal::kEmptyString) { + delete volume_id_; + } + if (volume_id) { + set_has_volume_id(); + volume_id_ = volume_id; + } else { + clear_has_volume_id(); + volume_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// repeated string file_ids = 2; +inline int xtreemfs_check_file_existsRequest::file_ids_size() const { + return file_ids_.size(); +} +inline void xtreemfs_check_file_existsRequest::clear_file_ids() { + file_ids_.Clear(); +} +inline const ::std::string& xtreemfs_check_file_existsRequest::file_ids(int index) const { + return file_ids_.Get(index); +} +inline ::std::string* xtreemfs_check_file_existsRequest::mutable_file_ids(int index) { + return file_ids_.Mutable(index); +} +inline void xtreemfs_check_file_existsRequest::set_file_ids(int index, const ::std::string& value) { + file_ids_.Mutable(index)->assign(value); +} +inline void xtreemfs_check_file_existsRequest::set_file_ids(int index, const char* value) { + file_ids_.Mutable(index)->assign(value); +} +inline void xtreemfs_check_file_existsRequest::set_file_ids(int index, const char* value, size_t size) { + file_ids_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_check_file_existsRequest::add_file_ids() { + return file_ids_.Add(); +} +inline void xtreemfs_check_file_existsRequest::add_file_ids(const ::std::string& value) { + file_ids_.Add()->assign(value); +} +inline void xtreemfs_check_file_existsRequest::add_file_ids(const char* value) { + file_ids_.Add()->assign(value); +} +inline void xtreemfs_check_file_existsRequest::add_file_ids(const char* value, size_t size) { + file_ids_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +xtreemfs_check_file_existsRequest::file_ids() const { + return file_ids_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +xtreemfs_check_file_existsRequest::mutable_file_ids() { + return &file_ids_; +} + +// required string osd_uuid = 3; +inline bool xtreemfs_check_file_existsRequest::has_osd_uuid() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_check_file_existsRequest::set_has_osd_uuid() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_check_file_existsRequest::clear_has_osd_uuid() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_check_file_existsRequest::clear_osd_uuid() { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + osd_uuid_->clear(); + } + clear_has_osd_uuid(); +} +inline const ::std::string& xtreemfs_check_file_existsRequest::osd_uuid() const { + return *osd_uuid_; +} +inline void xtreemfs_check_file_existsRequest::set_osd_uuid(const ::std::string& value) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(value); +} +inline void xtreemfs_check_file_existsRequest::set_osd_uuid(const char* value) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(value); +} +inline void xtreemfs_check_file_existsRequest::set_osd_uuid(const char* value, size_t size) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_check_file_existsRequest::mutable_osd_uuid() { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + return osd_uuid_; +} +inline ::std::string* xtreemfs_check_file_existsRequest::release_osd_uuid() { + clear_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = osd_uuid_; + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_check_file_existsRequest::set_allocated_osd_uuid(::std::string* osd_uuid) { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete osd_uuid_; + } + if (osd_uuid) { + set_has_osd_uuid(); + osd_uuid_ = osd_uuid; + } else { + clear_has_osd_uuid(); + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_check_file_existsResponse + +// required bool volume_exists = 1; +inline bool xtreemfs_check_file_existsResponse::has_volume_exists() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_check_file_existsResponse::set_has_volume_exists() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_check_file_existsResponse::clear_has_volume_exists() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_check_file_existsResponse::clear_volume_exists() { + volume_exists_ = false; + clear_has_volume_exists(); +} +inline bool xtreemfs_check_file_existsResponse::volume_exists() const { + return volume_exists_; +} +inline void xtreemfs_check_file_existsResponse::set_volume_exists(bool value) { + set_has_volume_exists(); + volume_exists_ = value; +} + +// repeated .xtreemfs.pbrpc.xtreemfs_check_file_existsResponse.FILE_STATE file_states = 2 [packed = true]; +inline int xtreemfs_check_file_existsResponse::file_states_size() const { + return file_states_.size(); +} +inline void xtreemfs_check_file_existsResponse::clear_file_states() { + file_states_.Clear(); +} +inline ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE xtreemfs_check_file_existsResponse::file_states(int index) const { + return static_cast< ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE >(file_states_.Get(index)); +} +inline void xtreemfs_check_file_existsResponse::set_file_states(int index, ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE value) { + assert(::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE_IsValid(value)); + file_states_.Set(index, value); +} +inline void xtreemfs_check_file_existsResponse::add_file_states(::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE value) { + assert(::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE_IsValid(value)); + file_states_.Add(value); +} +inline const ::google::protobuf::RepeatedField& +xtreemfs_check_file_existsResponse::file_states() const { + return file_states_; +} +inline ::google::protobuf::RepeatedField* +xtreemfs_check_file_existsResponse::mutable_file_states() { + return &file_states_; +} + +// ------------------------------------------------------------------- + +// xtreemfs_dump_restore_databaseRequest + +// required string dump_file = 1; +inline bool xtreemfs_dump_restore_databaseRequest::has_dump_file() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_dump_restore_databaseRequest::set_has_dump_file() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_dump_restore_databaseRequest::clear_has_dump_file() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_dump_restore_databaseRequest::clear_dump_file() { + if (dump_file_ != &::google::protobuf::internal::kEmptyString) { + dump_file_->clear(); + } + clear_has_dump_file(); +} +inline const ::std::string& xtreemfs_dump_restore_databaseRequest::dump_file() const { + return *dump_file_; +} +inline void xtreemfs_dump_restore_databaseRequest::set_dump_file(const ::std::string& value) { + set_has_dump_file(); + if (dump_file_ == &::google::protobuf::internal::kEmptyString) { + dump_file_ = new ::std::string; + } + dump_file_->assign(value); +} +inline void xtreemfs_dump_restore_databaseRequest::set_dump_file(const char* value) { + set_has_dump_file(); + if (dump_file_ == &::google::protobuf::internal::kEmptyString) { + dump_file_ = new ::std::string; + } + dump_file_->assign(value); +} +inline void xtreemfs_dump_restore_databaseRequest::set_dump_file(const char* value, size_t size) { + set_has_dump_file(); + if (dump_file_ == &::google::protobuf::internal::kEmptyString) { + dump_file_ = new ::std::string; + } + dump_file_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_dump_restore_databaseRequest::mutable_dump_file() { + set_has_dump_file(); + if (dump_file_ == &::google::protobuf::internal::kEmptyString) { + dump_file_ = new ::std::string; + } + return dump_file_; +} +inline ::std::string* xtreemfs_dump_restore_databaseRequest::release_dump_file() { + clear_has_dump_file(); + if (dump_file_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = dump_file_; + dump_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_dump_restore_databaseRequest::set_allocated_dump_file(::std::string* dump_file) { + if (dump_file_ != &::google::protobuf::internal::kEmptyString) { + delete dump_file_; + } + if (dump_file) { + set_has_dump_file(); + dump_file_ = dump_file; + } else { + clear_has_dump_file(); + dump_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_get_suitable_osdsRequest + +// optional string file_id = 1; +inline bool xtreemfs_get_suitable_osdsRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_get_suitable_osdsRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_get_suitable_osdsRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_get_suitable_osdsRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_get_suitable_osdsRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_get_suitable_osdsRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_get_suitable_osdsRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_get_suitable_osdsRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_get_suitable_osdsRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_get_suitable_osdsRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_get_suitable_osdsRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string path = 3; +inline bool xtreemfs_get_suitable_osdsRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_get_suitable_osdsRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_get_suitable_osdsRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_get_suitable_osdsRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& xtreemfs_get_suitable_osdsRequest::path() const { + return *path_; +} +inline void xtreemfs_get_suitable_osdsRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_get_suitable_osdsRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_get_suitable_osdsRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_get_suitable_osdsRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* xtreemfs_get_suitable_osdsRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_get_suitable_osdsRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string volume_name = 4; +inline bool xtreemfs_get_suitable_osdsRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_get_suitable_osdsRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_get_suitable_osdsRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_get_suitable_osdsRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& xtreemfs_get_suitable_osdsRequest::volume_name() const { + return *volume_name_; +} +inline void xtreemfs_get_suitable_osdsRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_get_suitable_osdsRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_get_suitable_osdsRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_get_suitable_osdsRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* xtreemfs_get_suitable_osdsRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_get_suitable_osdsRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 num_osds = 2; +inline bool xtreemfs_get_suitable_osdsRequest::has_num_osds() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_get_suitable_osdsRequest::set_has_num_osds() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_get_suitable_osdsRequest::clear_has_num_osds() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_get_suitable_osdsRequest::clear_num_osds() { + num_osds_ = 0u; + clear_has_num_osds(); +} +inline ::google::protobuf::uint32 xtreemfs_get_suitable_osdsRequest::num_osds() const { + return num_osds_; +} +inline void xtreemfs_get_suitable_osdsRequest::set_num_osds(::google::protobuf::uint32 value) { + set_has_num_osds(); + num_osds_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_get_suitable_osdsResponse + +// repeated string osd_uuids = 1; +inline int xtreemfs_get_suitable_osdsResponse::osd_uuids_size() const { + return osd_uuids_.size(); +} +inline void xtreemfs_get_suitable_osdsResponse::clear_osd_uuids() { + osd_uuids_.Clear(); +} +inline const ::std::string& xtreemfs_get_suitable_osdsResponse::osd_uuids(int index) const { + return osd_uuids_.Get(index); +} +inline ::std::string* xtreemfs_get_suitable_osdsResponse::mutable_osd_uuids(int index) { + return osd_uuids_.Mutable(index); +} +inline void xtreemfs_get_suitable_osdsResponse::set_osd_uuids(int index, const ::std::string& value) { + osd_uuids_.Mutable(index)->assign(value); +} +inline void xtreemfs_get_suitable_osdsResponse::set_osd_uuids(int index, const char* value) { + osd_uuids_.Mutable(index)->assign(value); +} +inline void xtreemfs_get_suitable_osdsResponse::set_osd_uuids(int index, const char* value, size_t size) { + osd_uuids_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_get_suitable_osdsResponse::add_osd_uuids() { + return osd_uuids_.Add(); +} +inline void xtreemfs_get_suitable_osdsResponse::add_osd_uuids(const ::std::string& value) { + osd_uuids_.Add()->assign(value); +} +inline void xtreemfs_get_suitable_osdsResponse::add_osd_uuids(const char* value) { + osd_uuids_.Add()->assign(value); +} +inline void xtreemfs_get_suitable_osdsResponse::add_osd_uuids(const char* value, size_t size) { + osd_uuids_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +xtreemfs_get_suitable_osdsResponse::osd_uuids() const { + return osd_uuids_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +xtreemfs_get_suitable_osdsResponse::mutable_osd_uuids() { + return &osd_uuids_; +} + +// ------------------------------------------------------------------- + +// timestampResponse + +// required fixed32 timestamp_s = 1; +inline bool timestampResponse::has_timestamp_s() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void timestampResponse::set_has_timestamp_s() { + _has_bits_[0] |= 0x00000001u; +} +inline void timestampResponse::clear_has_timestamp_s() { + _has_bits_[0] &= ~0x00000001u; +} +inline void timestampResponse::clear_timestamp_s() { + timestamp_s_ = 0u; + clear_has_timestamp_s(); +} +inline ::google::protobuf::uint32 timestampResponse::timestamp_s() const { + return timestamp_s_; +} +inline void timestampResponse::set_timestamp_s(::google::protobuf::uint32 value) { + set_has_timestamp_s(); + timestamp_s_ = value; +} + +// ------------------------------------------------------------------- + +// stringMessage + +// required string a_string = 1; +inline bool stringMessage::has_a_string() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void stringMessage::set_has_a_string() { + _has_bits_[0] |= 0x00000001u; +} +inline void stringMessage::clear_has_a_string() { + _has_bits_[0] &= ~0x00000001u; +} +inline void stringMessage::clear_a_string() { + if (a_string_ != &::google::protobuf::internal::kEmptyString) { + a_string_->clear(); + } + clear_has_a_string(); +} +inline const ::std::string& stringMessage::a_string() const { + return *a_string_; +} +inline void stringMessage::set_a_string(const ::std::string& value) { + set_has_a_string(); + if (a_string_ == &::google::protobuf::internal::kEmptyString) { + a_string_ = new ::std::string; + } + a_string_->assign(value); +} +inline void stringMessage::set_a_string(const char* value) { + set_has_a_string(); + if (a_string_ == &::google::protobuf::internal::kEmptyString) { + a_string_ = new ::std::string; + } + a_string_->assign(value); +} +inline void stringMessage::set_a_string(const char* value, size_t size) { + set_has_a_string(); + if (a_string_ == &::google::protobuf::internal::kEmptyString) { + a_string_ = new ::std::string; + } + a_string_->assign(reinterpret_cast(value), size); +} +inline ::std::string* stringMessage::mutable_a_string() { + set_has_a_string(); + if (a_string_ == &::google::protobuf::internal::kEmptyString) { + a_string_ = new ::std::string; + } + return a_string_; +} +inline ::std::string* stringMessage::release_a_string() { + clear_has_a_string(); + if (a_string_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = a_string_; + a_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void stringMessage::set_allocated_a_string(::std::string* a_string) { + if (a_string_ != &::google::protobuf::internal::kEmptyString) { + delete a_string_; + } + if (a_string) { + set_has_a_string(); + a_string_ = a_string; + } else { + clear_has_a_string(); + a_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_listdirRequest + +// required string path = 1; +inline bool xtreemfs_listdirRequest::has_path() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_listdirRequest::set_has_path() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_listdirRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_listdirRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& xtreemfs_listdirRequest::path() const { + return *path_; +} +inline void xtreemfs_listdirRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_listdirRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_listdirRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_listdirRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* xtreemfs_listdirRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_listdirRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_listdirResponse + +// repeated string names = 1; +inline int xtreemfs_listdirResponse::names_size() const { + return names_.size(); +} +inline void xtreemfs_listdirResponse::clear_names() { + names_.Clear(); +} +inline const ::std::string& xtreemfs_listdirResponse::names(int index) const { + return names_.Get(index); +} +inline ::std::string* xtreemfs_listdirResponse::mutable_names(int index) { + return names_.Mutable(index); +} +inline void xtreemfs_listdirResponse::set_names(int index, const ::std::string& value) { + names_.Mutable(index)->assign(value); +} +inline void xtreemfs_listdirResponse::set_names(int index, const char* value) { + names_.Mutable(index)->assign(value); +} +inline void xtreemfs_listdirResponse::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_listdirResponse::add_names() { + return names_.Add(); +} +inline void xtreemfs_listdirResponse::add_names(const ::std::string& value) { + names_.Add()->assign(value); +} +inline void xtreemfs_listdirResponse::add_names(const char* value) { + names_.Add()->assign(value); +} +inline void xtreemfs_listdirResponse::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +xtreemfs_listdirResponse::names() const { + return names_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +xtreemfs_listdirResponse::mutable_names() { + return &names_; +} + +// ------------------------------------------------------------------- + +// xtreemfs_replica_addRequest + +// optional string file_id = 1; +inline bool xtreemfs_replica_addRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_replica_addRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_replica_addRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_replica_addRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_replica_addRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_replica_addRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_replica_addRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_replica_addRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_addRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_replica_addRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_addRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string path = 3; +inline bool xtreemfs_replica_addRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_replica_addRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_replica_addRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_replica_addRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& xtreemfs_replica_addRequest::path() const { + return *path_; +} +inline void xtreemfs_replica_addRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_replica_addRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_replica_addRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_addRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* xtreemfs_replica_addRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_addRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string volume_name = 4; +inline bool xtreemfs_replica_addRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_replica_addRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_replica_addRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_replica_addRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& xtreemfs_replica_addRequest::volume_name() const { + return *volume_name_; +} +inline void xtreemfs_replica_addRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_replica_addRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_replica_addRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_addRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* xtreemfs_replica_addRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_addRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required .xtreemfs.pbrpc.Replica new_replica = 2; +inline bool xtreemfs_replica_addRequest::has_new_replica() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_replica_addRequest::set_has_new_replica() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_replica_addRequest::clear_has_new_replica() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_replica_addRequest::clear_new_replica() { + if (new_replica_ != NULL) new_replica_->::xtreemfs::pbrpc::Replica::Clear(); + clear_has_new_replica(); +} +inline const ::xtreemfs::pbrpc::Replica& xtreemfs_replica_addRequest::new_replica() const { + return new_replica_ != NULL ? *new_replica_ : *default_instance_->new_replica_; +} +inline ::xtreemfs::pbrpc::Replica* xtreemfs_replica_addRequest::mutable_new_replica() { + set_has_new_replica(); + if (new_replica_ == NULL) new_replica_ = new ::xtreemfs::pbrpc::Replica; + return new_replica_; +} +inline ::xtreemfs::pbrpc::Replica* xtreemfs_replica_addRequest::release_new_replica() { + clear_has_new_replica(); + ::xtreemfs::pbrpc::Replica* temp = new_replica_; + new_replica_ = NULL; + return temp; +} +inline void xtreemfs_replica_addRequest::set_allocated_new_replica(::xtreemfs::pbrpc::Replica* new_replica) { + delete new_replica_; + new_replica_ = new_replica; + if (new_replica) { + set_has_new_replica(); + } else { + clear_has_new_replica(); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_replica_listRequest + +// optional string file_id = 1; +inline bool xtreemfs_replica_listRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_replica_listRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_replica_listRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_replica_listRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_replica_listRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_replica_listRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_replica_listRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_replica_listRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_listRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_replica_listRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_listRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string path = 2; +inline bool xtreemfs_replica_listRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_replica_listRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_replica_listRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_replica_listRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& xtreemfs_replica_listRequest::path() const { + return *path_; +} +inline void xtreemfs_replica_listRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_replica_listRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_replica_listRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_listRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* xtreemfs_replica_listRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_listRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string volume_name = 3; +inline bool xtreemfs_replica_listRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_replica_listRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_replica_listRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_replica_listRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& xtreemfs_replica_listRequest::volume_name() const { + return *volume_name_; +} +inline void xtreemfs_replica_listRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_replica_listRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_replica_listRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_listRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* xtreemfs_replica_listRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_listRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_get_xlocsetRequest + +// optional string file_id = 1; +inline bool xtreemfs_get_xlocsetRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_get_xlocsetRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_get_xlocsetRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_get_xlocsetRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_get_xlocsetRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_get_xlocsetRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_get_xlocsetRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_get_xlocsetRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_get_xlocsetRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_get_xlocsetRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_get_xlocsetRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string path = 2; +inline bool xtreemfs_get_xlocsetRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_get_xlocsetRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_get_xlocsetRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_get_xlocsetRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& xtreemfs_get_xlocsetRequest::path() const { + return *path_; +} +inline void xtreemfs_get_xlocsetRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_get_xlocsetRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_get_xlocsetRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_get_xlocsetRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* xtreemfs_get_xlocsetRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_get_xlocsetRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string volume_name = 3; +inline bool xtreemfs_get_xlocsetRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_get_xlocsetRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_get_xlocsetRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_get_xlocsetRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& xtreemfs_get_xlocsetRequest::volume_name() const { + return *volume_name_; +} +inline void xtreemfs_get_xlocsetRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_get_xlocsetRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_get_xlocsetRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_get_xlocsetRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* xtreemfs_get_xlocsetRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_get_xlocsetRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional .xtreemfs.pbrpc.XCap xcap = 4; +inline bool xtreemfs_get_xlocsetRequest::has_xcap() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_get_xlocsetRequest::set_has_xcap() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_get_xlocsetRequest::clear_has_xcap() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_get_xlocsetRequest::clear_xcap() { + if (xcap_ != NULL) xcap_->::xtreemfs::pbrpc::XCap::Clear(); + clear_has_xcap(); +} +inline const ::xtreemfs::pbrpc::XCap& xtreemfs_get_xlocsetRequest::xcap() const { + return xcap_ != NULL ? *xcap_ : *default_instance_->xcap_; +} +inline ::xtreemfs::pbrpc::XCap* xtreemfs_get_xlocsetRequest::mutable_xcap() { + set_has_xcap(); + if (xcap_ == NULL) xcap_ = new ::xtreemfs::pbrpc::XCap; + return xcap_; +} +inline ::xtreemfs::pbrpc::XCap* xtreemfs_get_xlocsetRequest::release_xcap() { + clear_has_xcap(); + ::xtreemfs::pbrpc::XCap* temp = xcap_; + xcap_ = NULL; + return temp; +} +inline void xtreemfs_get_xlocsetRequest::set_allocated_xcap(::xtreemfs::pbrpc::XCap* xcap) { + delete xcap_; + xcap_ = xcap; + if (xcap) { + set_has_xcap(); + } else { + clear_has_xcap(); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_replica_removeRequest + +// optional string file_id = 1; +inline bool xtreemfs_replica_removeRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_replica_removeRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_replica_removeRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_replica_removeRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_replica_removeRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_replica_removeRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_replica_removeRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_replica_removeRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_removeRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_replica_removeRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_removeRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string path = 3; +inline bool xtreemfs_replica_removeRequest::has_path() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_replica_removeRequest::set_has_path() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_replica_removeRequest::clear_has_path() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_replica_removeRequest::clear_path() { + if (path_ != &::google::protobuf::internal::kEmptyString) { + path_->clear(); + } + clear_has_path(); +} +inline const ::std::string& xtreemfs_replica_removeRequest::path() const { + return *path_; +} +inline void xtreemfs_replica_removeRequest::set_path(const ::std::string& value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_replica_removeRequest::set_path(const char* value) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(value); +} +inline void xtreemfs_replica_removeRequest::set_path(const char* value, size_t size) { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_removeRequest::mutable_path() { + set_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + path_ = new ::std::string; + } + return path_; +} +inline ::std::string* xtreemfs_replica_removeRequest::release_path() { + clear_has_path(); + if (path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = path_; + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_removeRequest::set_allocated_path(::std::string* path) { + if (path_ != &::google::protobuf::internal::kEmptyString) { + delete path_; + } + if (path) { + set_has_path(); + path_ = path; + } else { + clear_has_path(); + path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string volume_name = 4; +inline bool xtreemfs_replica_removeRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_replica_removeRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_replica_removeRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_replica_removeRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& xtreemfs_replica_removeRequest::volume_name() const { + return *volume_name_; +} +inline void xtreemfs_replica_removeRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_replica_removeRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_replica_removeRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_removeRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* xtreemfs_replica_removeRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_removeRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string osd_uuid = 2; +inline bool xtreemfs_replica_removeRequest::has_osd_uuid() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_replica_removeRequest::set_has_osd_uuid() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_replica_removeRequest::clear_has_osd_uuid() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_replica_removeRequest::clear_osd_uuid() { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + osd_uuid_->clear(); + } + clear_has_osd_uuid(); +} +inline const ::std::string& xtreemfs_replica_removeRequest::osd_uuid() const { + return *osd_uuid_; +} +inline void xtreemfs_replica_removeRequest::set_osd_uuid(const ::std::string& value) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(value); +} +inline void xtreemfs_replica_removeRequest::set_osd_uuid(const char* value) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(value); +} +inline void xtreemfs_replica_removeRequest::set_osd_uuid(const char* value, size_t size) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_replica_removeRequest::mutable_osd_uuid() { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + return osd_uuid_; +} +inline ::std::string* xtreemfs_replica_removeRequest::release_osd_uuid() { + clear_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = osd_uuid_; + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_replica_removeRequest::set_allocated_osd_uuid(::std::string* osd_uuid) { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete osd_uuid_; + } + if (osd_uuid) { + set_has_osd_uuid(); + osd_uuid_ = osd_uuid; + } else { + clear_has_osd_uuid(); + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_restore_fileRequest + +// required string file_path = 1; +inline bool xtreemfs_restore_fileRequest::has_file_path() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_restore_fileRequest::set_has_file_path() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_restore_fileRequest::clear_has_file_path() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_restore_fileRequest::clear_file_path() { + if (file_path_ != &::google::protobuf::internal::kEmptyString) { + file_path_->clear(); + } + clear_has_file_path(); +} +inline const ::std::string& xtreemfs_restore_fileRequest::file_path() const { + return *file_path_; +} +inline void xtreemfs_restore_fileRequest::set_file_path(const ::std::string& value) { + set_has_file_path(); + if (file_path_ == &::google::protobuf::internal::kEmptyString) { + file_path_ = new ::std::string; + } + file_path_->assign(value); +} +inline void xtreemfs_restore_fileRequest::set_file_path(const char* value) { + set_has_file_path(); + if (file_path_ == &::google::protobuf::internal::kEmptyString) { + file_path_ = new ::std::string; + } + file_path_->assign(value); +} +inline void xtreemfs_restore_fileRequest::set_file_path(const char* value, size_t size) { + set_has_file_path(); + if (file_path_ == &::google::protobuf::internal::kEmptyString) { + file_path_ = new ::std::string; + } + file_path_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_restore_fileRequest::mutable_file_path() { + set_has_file_path(); + if (file_path_ == &::google::protobuf::internal::kEmptyString) { + file_path_ = new ::std::string; + } + return file_path_; +} +inline ::std::string* xtreemfs_restore_fileRequest::release_file_path() { + clear_has_file_path(); + if (file_path_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_path_; + file_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_restore_fileRequest::set_allocated_file_path(::std::string* file_path) { + if (file_path_ != &::google::protobuf::internal::kEmptyString) { + delete file_path_; + } + if (file_path) { + set_has_file_path(); + file_path_ = file_path; + } else { + clear_has_file_path(); + file_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string file_id = 2; +inline bool xtreemfs_restore_fileRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_restore_fileRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_restore_fileRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_restore_fileRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_restore_fileRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_restore_fileRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_restore_fileRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_restore_fileRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_restore_fileRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_restore_fileRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_restore_fileRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 file_size = 3; +inline bool xtreemfs_restore_fileRequest::has_file_size() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_restore_fileRequest::set_has_file_size() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_restore_fileRequest::clear_has_file_size() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_restore_fileRequest::clear_file_size() { + file_size_ = GOOGLE_ULONGLONG(0); + clear_has_file_size(); +} +inline ::google::protobuf::uint64 xtreemfs_restore_fileRequest::file_size() const { + return file_size_; +} +inline void xtreemfs_restore_fileRequest::set_file_size(::google::protobuf::uint64 value) { + set_has_file_size(); + file_size_ = value; +} + +// required string osd_uuid = 4; +inline bool xtreemfs_restore_fileRequest::has_osd_uuid() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_restore_fileRequest::set_has_osd_uuid() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_restore_fileRequest::clear_has_osd_uuid() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_restore_fileRequest::clear_osd_uuid() { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + osd_uuid_->clear(); + } + clear_has_osd_uuid(); +} +inline const ::std::string& xtreemfs_restore_fileRequest::osd_uuid() const { + return *osd_uuid_; +} +inline void xtreemfs_restore_fileRequest::set_osd_uuid(const ::std::string& value) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(value); +} +inline void xtreemfs_restore_fileRequest::set_osd_uuid(const char* value) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(value); +} +inline void xtreemfs_restore_fileRequest::set_osd_uuid(const char* value, size_t size) { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + osd_uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_restore_fileRequest::mutable_osd_uuid() { + set_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + osd_uuid_ = new ::std::string; + } + return osd_uuid_; +} +inline ::std::string* xtreemfs_restore_fileRequest::release_osd_uuid() { + clear_has_osd_uuid(); + if (osd_uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = osd_uuid_; + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_restore_fileRequest::set_allocated_osd_uuid(::std::string* osd_uuid) { + if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete osd_uuid_; + } + if (osd_uuid) { + set_has_osd_uuid(); + osd_uuid_ = osd_uuid; + } else { + clear_has_osd_uuid(); + osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 stripe_size = 5; +inline bool xtreemfs_restore_fileRequest::has_stripe_size() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void xtreemfs_restore_fileRequest::set_has_stripe_size() { + _has_bits_[0] |= 0x00000010u; +} +inline void xtreemfs_restore_fileRequest::clear_has_stripe_size() { + _has_bits_[0] &= ~0x00000010u; +} +inline void xtreemfs_restore_fileRequest::clear_stripe_size() { + stripe_size_ = 0u; + clear_has_stripe_size(); +} +inline ::google::protobuf::uint32 xtreemfs_restore_fileRequest::stripe_size() const { + return stripe_size_; +} +inline void xtreemfs_restore_fileRequest::set_stripe_size(::google::protobuf::uint32 value) { + set_has_stripe_size(); + stripe_size_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_rmvolRequest + +// required string volume_name = 1; +inline bool xtreemfs_rmvolRequest::has_volume_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rmvolRequest::set_has_volume_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rmvolRequest::clear_has_volume_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rmvolRequest::clear_volume_name() { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + volume_name_->clear(); + } + clear_has_volume_name(); +} +inline const ::std::string& xtreemfs_rmvolRequest::volume_name() const { + return *volume_name_; +} +inline void xtreemfs_rmvolRequest::set_volume_name(const ::std::string& value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_rmvolRequest::set_volume_name(const char* value) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(value); +} +inline void xtreemfs_rmvolRequest::set_volume_name(const char* value, size_t size) { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + volume_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rmvolRequest::mutable_volume_name() { + set_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + volume_name_ = new ::std::string; + } + return volume_name_; +} +inline ::std::string* xtreemfs_rmvolRequest::release_volume_name() { + clear_has_volume_name(); + if (volume_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = volume_name_; + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rmvolRequest::set_allocated_volume_name(::std::string* volume_name) { + if (volume_name_ != &::google::protobuf::internal::kEmptyString) { + delete volume_name_; + } + if (volume_name) { + set_has_volume_name(); + volume_name_ = volume_name; + } else { + clear_has_volume_name(); + volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_update_file_sizeRequest + +// required .xtreemfs.pbrpc.XCap xcap = 1; +inline bool xtreemfs_update_file_sizeRequest::has_xcap() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_update_file_sizeRequest::set_has_xcap() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_update_file_sizeRequest::clear_has_xcap() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_update_file_sizeRequest::clear_xcap() { + if (xcap_ != NULL) xcap_->::xtreemfs::pbrpc::XCap::Clear(); + clear_has_xcap(); +} +inline const ::xtreemfs::pbrpc::XCap& xtreemfs_update_file_sizeRequest::xcap() const { + return xcap_ != NULL ? *xcap_ : *default_instance_->xcap_; +} +inline ::xtreemfs::pbrpc::XCap* xtreemfs_update_file_sizeRequest::mutable_xcap() { + set_has_xcap(); + if (xcap_ == NULL) xcap_ = new ::xtreemfs::pbrpc::XCap; + return xcap_; +} +inline ::xtreemfs::pbrpc::XCap* xtreemfs_update_file_sizeRequest::release_xcap() { + clear_has_xcap(); + ::xtreemfs::pbrpc::XCap* temp = xcap_; + xcap_ = NULL; + return temp; +} +inline void xtreemfs_update_file_sizeRequest::set_allocated_xcap(::xtreemfs::pbrpc::XCap* xcap) { + delete xcap_; + xcap_ = xcap; + if (xcap) { + set_has_xcap(); + } else { + clear_has_xcap(); + } +} + +// required .xtreemfs.pbrpc.OSDWriteResponse osd_write_response = 2; +inline bool xtreemfs_update_file_sizeRequest::has_osd_write_response() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_update_file_sizeRequest::set_has_osd_write_response() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_update_file_sizeRequest::clear_has_osd_write_response() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_update_file_sizeRequest::clear_osd_write_response() { + if (osd_write_response_ != NULL) osd_write_response_->::xtreemfs::pbrpc::OSDWriteResponse::Clear(); + clear_has_osd_write_response(); +} +inline const ::xtreemfs::pbrpc::OSDWriteResponse& xtreemfs_update_file_sizeRequest::osd_write_response() const { + return osd_write_response_ != NULL ? *osd_write_response_ : *default_instance_->osd_write_response_; +} +inline ::xtreemfs::pbrpc::OSDWriteResponse* xtreemfs_update_file_sizeRequest::mutable_osd_write_response() { + set_has_osd_write_response(); + if (osd_write_response_ == NULL) osd_write_response_ = new ::xtreemfs::pbrpc::OSDWriteResponse; + return osd_write_response_; +} +inline ::xtreemfs::pbrpc::OSDWriteResponse* xtreemfs_update_file_sizeRequest::release_osd_write_response() { + clear_has_osd_write_response(); + ::xtreemfs::pbrpc::OSDWriteResponse* temp = osd_write_response_; + osd_write_response_ = NULL; + return temp; +} +inline void xtreemfs_update_file_sizeRequest::set_allocated_osd_write_response(::xtreemfs::pbrpc::OSDWriteResponse* osd_write_response) { + delete osd_write_response_; + osd_write_response_ = osd_write_response; + if (osd_write_response) { + set_has_osd_write_response(); + } else { + clear_has_osd_write_response(); + } +} + +// optional bool close_file = 3; +inline bool xtreemfs_update_file_sizeRequest::has_close_file() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_update_file_sizeRequest::set_has_close_file() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_update_file_sizeRequest::clear_has_close_file() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_update_file_sizeRequest::clear_close_file() { + close_file_ = false; + clear_has_close_file(); +} +inline bool xtreemfs_update_file_sizeRequest::close_file() const { + return close_file_; +} +inline void xtreemfs_update_file_sizeRequest::set_close_file(bool value) { + set_has_close_file(); + close_file_ = value; +} + +// optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 4; +inline bool xtreemfs_update_file_sizeRequest::has_coordinates() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_update_file_sizeRequest::set_has_coordinates() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_update_file_sizeRequest::clear_has_coordinates() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_update_file_sizeRequest::clear_coordinates() { + if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear(); + clear_has_coordinates(); +} +inline const ::xtreemfs::pbrpc::VivaldiCoordinates& xtreemfs_update_file_sizeRequest::coordinates() const { + return coordinates_ != NULL ? *coordinates_ : *default_instance_->coordinates_; +} +inline ::xtreemfs::pbrpc::VivaldiCoordinates* xtreemfs_update_file_sizeRequest::mutable_coordinates() { + set_has_coordinates(); + if (coordinates_ == NULL) coordinates_ = new ::xtreemfs::pbrpc::VivaldiCoordinates; + return coordinates_; +} +inline ::xtreemfs::pbrpc::VivaldiCoordinates* xtreemfs_update_file_sizeRequest::release_coordinates() { + clear_has_coordinates(); + ::xtreemfs::pbrpc::VivaldiCoordinates* temp = coordinates_; + coordinates_ = NULL; + return temp; +} +inline void xtreemfs_update_file_sizeRequest::set_allocated_coordinates(::xtreemfs::pbrpc::VivaldiCoordinates* coordinates) { + delete coordinates_; + coordinates_ = coordinates; + if (coordinates) { + set_has_coordinates(); + } else { + clear_has_coordinates(); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_set_replica_update_policyRequest + +// required string file_id = 1; +inline bool xtreemfs_set_replica_update_policyRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_set_replica_update_policyRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_set_replica_update_policyRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_set_replica_update_policyRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_set_replica_update_policyRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_set_replica_update_policyRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_set_replica_update_policyRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_set_replica_update_policyRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_set_replica_update_policyRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_set_replica_update_policyRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_set_replica_update_policyRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string update_policy = 2; +inline bool xtreemfs_set_replica_update_policyRequest::has_update_policy() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_set_replica_update_policyRequest::set_has_update_policy() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_set_replica_update_policyRequest::clear_has_update_policy() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_set_replica_update_policyRequest::clear_update_policy() { + if (update_policy_ != &::google::protobuf::internal::kEmptyString) { + update_policy_->clear(); + } + clear_has_update_policy(); +} +inline const ::std::string& xtreemfs_set_replica_update_policyRequest::update_policy() const { + return *update_policy_; +} +inline void xtreemfs_set_replica_update_policyRequest::set_update_policy(const ::std::string& value) { + set_has_update_policy(); + if (update_policy_ == &::google::protobuf::internal::kEmptyString) { + update_policy_ = new ::std::string; + } + update_policy_->assign(value); +} +inline void xtreemfs_set_replica_update_policyRequest::set_update_policy(const char* value) { + set_has_update_policy(); + if (update_policy_ == &::google::protobuf::internal::kEmptyString) { + update_policy_ = new ::std::string; + } + update_policy_->assign(value); +} +inline void xtreemfs_set_replica_update_policyRequest::set_update_policy(const char* value, size_t size) { + set_has_update_policy(); + if (update_policy_ == &::google::protobuf::internal::kEmptyString) { + update_policy_ = new ::std::string; + } + update_policy_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_set_replica_update_policyRequest::mutable_update_policy() { + set_has_update_policy(); + if (update_policy_ == &::google::protobuf::internal::kEmptyString) { + update_policy_ = new ::std::string; + } + return update_policy_; +} +inline ::std::string* xtreemfs_set_replica_update_policyRequest::release_update_policy() { + clear_has_update_policy(); + if (update_policy_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = update_policy_; + update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_set_replica_update_policyRequest::set_allocated_update_policy(::std::string* update_policy) { + if (update_policy_ != &::google::protobuf::internal::kEmptyString) { + delete update_policy_; + } + if (update_policy) { + set_has_update_policy(); + update_policy_ = update_policy; + } else { + clear_has_update_policy(); + update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_set_replica_update_policyResponse + +// required string old_update_policy = 1; +inline bool xtreemfs_set_replica_update_policyResponse::has_old_update_policy() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_set_replica_update_policyResponse::set_has_old_update_policy() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_set_replica_update_policyResponse::clear_has_old_update_policy() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_set_replica_update_policyResponse::clear_old_update_policy() { + if (old_update_policy_ != &::google::protobuf::internal::kEmptyString) { + old_update_policy_->clear(); + } + clear_has_old_update_policy(); +} +inline const ::std::string& xtreemfs_set_replica_update_policyResponse::old_update_policy() const { + return *old_update_policy_; +} +inline void xtreemfs_set_replica_update_policyResponse::set_old_update_policy(const ::std::string& value) { + set_has_old_update_policy(); + if (old_update_policy_ == &::google::protobuf::internal::kEmptyString) { + old_update_policy_ = new ::std::string; + } + old_update_policy_->assign(value); +} +inline void xtreemfs_set_replica_update_policyResponse::set_old_update_policy(const char* value) { + set_has_old_update_policy(); + if (old_update_policy_ == &::google::protobuf::internal::kEmptyString) { + old_update_policy_ = new ::std::string; + } + old_update_policy_->assign(value); +} +inline void xtreemfs_set_replica_update_policyResponse::set_old_update_policy(const char* value, size_t size) { + set_has_old_update_policy(); + if (old_update_policy_ == &::google::protobuf::internal::kEmptyString) { + old_update_policy_ = new ::std::string; + } + old_update_policy_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_set_replica_update_policyResponse::mutable_old_update_policy() { + set_has_old_update_policy(); + if (old_update_policy_ == &::google::protobuf::internal::kEmptyString) { + old_update_policy_ = new ::std::string; + } + return old_update_policy_; +} +inline ::std::string* xtreemfs_set_replica_update_policyResponse::release_old_update_policy() { + clear_has_old_update_policy(); + if (old_update_policy_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = old_update_policy_; + old_update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_set_replica_update_policyResponse::set_allocated_old_update_policy(::std::string* old_update_policy) { + if (old_update_policy_ != &::google::protobuf::internal::kEmptyString) { + delete old_update_policy_; + } + if (old_update_policy) { + set_has_old_update_policy(); + old_update_policy_ = old_update_policy; + } else { + clear_has_old_update_policy(); + old_update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_set_read_only_xattrRequest + +// required string file_id = 1; +inline bool xtreemfs_set_read_only_xattrRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_set_read_only_xattrRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_set_read_only_xattrRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_set_read_only_xattrRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_set_read_only_xattrRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_set_read_only_xattrRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_set_read_only_xattrRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_set_read_only_xattrRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_set_read_only_xattrRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_set_read_only_xattrRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_set_read_only_xattrRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required bool value = 2; +inline bool xtreemfs_set_read_only_xattrRequest::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_set_read_only_xattrRequest::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_set_read_only_xattrRequest::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_set_read_only_xattrRequest::clear_value() { + value_ = false; + clear_has_value(); +} +inline bool xtreemfs_set_read_only_xattrRequest::value() const { + return value_; +} +inline void xtreemfs_set_read_only_xattrRequest::set_value(bool value) { + set_has_value(); + value_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_set_read_only_xattrResponse + +// required bool was_set = 1; +inline bool xtreemfs_set_read_only_xattrResponse::has_was_set() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_set_read_only_xattrResponse::set_has_was_set() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_set_read_only_xattrResponse::clear_has_was_set() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_set_read_only_xattrResponse::clear_was_set() { + was_set_ = false; + clear_has_was_set(); +} +inline bool xtreemfs_set_read_only_xattrResponse::was_set() const { + return was_set_; +} +inline void xtreemfs_set_read_only_xattrResponse::set_was_set(bool value) { + set_has_was_set(); + was_set_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_get_file_credentialsRequest + +// required string file_id = 1; +inline bool xtreemfs_get_file_credentialsRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_get_file_credentialsRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_get_file_credentialsRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_get_file_credentialsRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_get_file_credentialsRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_get_file_credentialsRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_get_file_credentialsRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_get_file_credentialsRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_get_file_credentialsRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_get_file_credentialsRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_get_file_credentialsRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE>() { + return ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse_FILE_STATE_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::Setattrs>() { + return ::xtreemfs::pbrpc::Setattrs_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::XATTR_FLAGS>() { + return ::xtreemfs::pbrpc::XATTR_FLAGS_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::ACCESS_FLAGS>() { + return ::xtreemfs::pbrpc::ACCESS_FLAGS_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_xtreemfs_2fMRC_2eproto__INCLUDED diff --git a/cpp/generated/xtreemfs/MRCServiceClient.h b/cpp/generated/xtreemfs/MRCServiceClient.h new file mode 100644 index 0000000..70cd4b4 --- /dev/null +++ b/cpp/generated/xtreemfs/MRCServiceClient.h @@ -0,0 +1,981 @@ +//automatically generated from MRC.proto at Thu Dec 11 16:09:40 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef MRCSERVICECLIENT_H +#define MRCSERVICECLIENT_H + +#include +#include "pbrpc/RPC.pb.h" +#include "rpc/client.h" +#include "rpc/sync_callback.h" +#include "rpc/callback_interface.h" +#include "xtreemfs/MRC.pb.h" +#include "include/Common.pb.h" +#include "xtreemfs/GlobalTypes.pb.h" +#include "xtreemfs/DIR.pb.h" + + +namespace xtreemfs { +namespace pbrpc { + using ::xtreemfs::rpc::Client; + using ::xtreemfs::rpc::CallbackInterface; + using ::xtreemfs::rpc::SyncCallback; + + class MRCServiceClient { + + public: + MRCServiceClient(Client* client) : client_(client) { + } + + virtual ~MRCServiceClient() { + } + + void fsetattr(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::fsetattrRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 2, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* fsetattr_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::fsetattrRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 2, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void ftruncate(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::XCap* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 3, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::XCap(), + context, callback); + } + + SyncCallback* ftruncate_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::XCap* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 3, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::XCap(), + NULL, sync_cb); + return sync_cb; + } + + void getattr(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::getattrRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 4, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::getattrResponse(), + context, callback); + } + + SyncCallback* getattr_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::getattrRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 4, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::getattrResponse(), + NULL, sync_cb); + return sync_cb; + } + + void getxattr(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::getxattrRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 5, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::getxattrResponse(), + context, callback); + } + + SyncCallback* getxattr_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::getxattrRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 5, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::getxattrResponse(), + NULL, sync_cb); + return sync_cb; + } + + void link(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::linkRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 6, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + context, callback); + } + + SyncCallback* link_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::linkRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 6, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + NULL, sync_cb); + return sync_cb; + } + + void listxattr(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::listxattrRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 7, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::listxattrResponse(), + context, callback); + } + + SyncCallback* listxattr_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::listxattrRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 7, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::listxattrResponse(), + NULL, sync_cb); + return sync_cb; + } + + void mkdir(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::mkdirRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 8, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + context, callback); + } + + SyncCallback* mkdir_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::mkdirRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 8, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + NULL, sync_cb); + return sync_cb; + } + + void open(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::openRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 9, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::openResponse(), + context, callback); + } + + SyncCallback* open_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::openRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 9, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::openResponse(), + NULL, sync_cb); + return sync_cb; + } + + void readdir(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::readdirRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 10, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::DirectoryEntries(), + context, callback); + } + + SyncCallback* readdir_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::readdirRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 10, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::DirectoryEntries(), + NULL, sync_cb); + return sync_cb; + } + + void readlink(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::readlinkRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 11, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::readlinkResponse(), + context, callback); + } + + SyncCallback* readlink_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::readlinkRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 11, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::readlinkResponse(), + NULL, sync_cb); + return sync_cb; + } + + void removexattr(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::removexattrRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 12, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + context, callback); + } + + SyncCallback* removexattr_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::removexattrRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 12, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + NULL, sync_cb); + return sync_cb; + } + + void rename(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::renameRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 13, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::renameResponse(), + context, callback); + } + + SyncCallback* rename_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::renameRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 13, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::renameResponse(), + NULL, sync_cb); + return sync_cb; + } + + void rmdir(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::rmdirRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 14, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + context, callback); + } + + SyncCallback* rmdir_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::rmdirRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 14, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + NULL, sync_cb); + return sync_cb; + } + + void setattr(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::setattrRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 15, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + context, callback); + } + + SyncCallback* setattr_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::setattrRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 15, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + NULL, sync_cb); + return sync_cb; + } + + void setxattr(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::setxattrRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 16, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + context, callback); + } + + SyncCallback* setxattr_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::setxattrRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 16, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + NULL, sync_cb); + return sync_cb; + } + + void statvfs(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::statvfsRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 17, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::StatVFS(), + context, callback); + } + + SyncCallback* statvfs_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::statvfsRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 17, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::StatVFS(), + NULL, sync_cb); + return sync_cb; + } + + void symlink(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::symlinkRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 18, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + context, callback); + } + + SyncCallback* symlink_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::symlinkRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 18, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + NULL, sync_cb); + return sync_cb; + } + + void unlink(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::unlinkRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 19, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::unlinkResponse(), + context, callback); + } + + SyncCallback* unlink_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::unlinkRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 19, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::unlinkResponse(), + NULL, sync_cb); + return sync_cb; + } + + void access(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::accessRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 20, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* access_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::accessRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 20, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_checkpoint(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 20001, 30, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_checkpoint_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 30, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_check_file_exists(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_check_file_existsRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 31, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_check_file_existsResponse(), + context, callback); + } + + SyncCallback* xtreemfs_check_file_exists_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_check_file_existsRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 31, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_check_file_existsResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_dump_database(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 32, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_dump_database_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 32, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_get_suitable_osds(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_get_suitable_osdsRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 33, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_get_suitable_osdsResponse(), + context, callback); + } + + SyncCallback* xtreemfs_get_suitable_osds_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_get_suitable_osdsRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 33, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_get_suitable_osdsResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_internal_debug(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::stringMessage* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 34, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::stringMessage(), + context, callback); + } + + SyncCallback* xtreemfs_internal_debug_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::stringMessage* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 34, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::stringMessage(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_listdir(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_listdirRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 35, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_listdirResponse(), + context, callback); + } + + SyncCallback* xtreemfs_listdir_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_listdirRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 35, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_listdirResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_lsvol(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 20001, 36, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Volumes(), + context, callback); + } + + SyncCallback* xtreemfs_lsvol_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 36, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Volumes(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_mkvol(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::Volume* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 47, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_mkvol_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::Volume* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 47, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_renew_capability(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::XCap* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 37, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::XCap(), + context, callback); + } + + SyncCallback* xtreemfs_renew_capability_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::XCap* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 37, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::XCap(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_replication_to_master(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 20001, 38, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_replication_to_master_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 38, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_replica_add(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_replica_addRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 39, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_replica_add_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_replica_addRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 39, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_replica_list(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_replica_listRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 40, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Replicas(), + context, callback); + } + + SyncCallback* xtreemfs_replica_list_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_replica_listRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 40, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Replicas(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_replica_remove(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_replica_removeRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 41, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::FileCredentials(), + context, callback); + } + + SyncCallback* xtreemfs_replica_remove_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_replica_removeRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 41, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::FileCredentials(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_restore_database(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 42, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_restore_database_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 42, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_restore_file(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_restore_fileRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 43, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_restore_file_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_restore_fileRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 43, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rmvol(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rmvolRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 44, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_rmvol_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rmvolRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 44, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_shutdown(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 20001, 45, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_shutdown_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 45, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_update_file_size(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_update_file_sizeRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 46, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + context, callback); + } + + SyncCallback* xtreemfs_update_file_size_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_update_file_sizeRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 46, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::timestampResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_set_replica_update_policy(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_set_replica_update_policyRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 48, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_set_replica_update_policyResponse(), + context, callback); + } + + SyncCallback* xtreemfs_set_replica_update_policy_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_set_replica_update_policyRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 48, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_set_replica_update_policyResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_set_read_only_xattr(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_set_read_only_xattrRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 49, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_set_read_only_xattrResponse(), + context, callback); + } + + SyncCallback* xtreemfs_set_read_only_xattr_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_set_read_only_xattrRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 49, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_set_read_only_xattrResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_get_file_credentials(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_get_file_credentialsRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 50, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::FileCredentials(), + context, callback); + } + + SyncCallback* xtreemfs_get_file_credentials_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_get_file_credentialsRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 50, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::FileCredentials(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_get_xlocset(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_get_xlocsetRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 20001, 51, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::XLocSet(), + context, callback); + } + + SyncCallback* xtreemfs_get_xlocset_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_get_xlocsetRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 20001, 51, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::XLocSet(), + NULL, sync_cb); + return sync_cb; + } + + private: + Client* client_; + }; + } +} +#endif //MRCSERVICECLIENT_H diff --git a/cpp/generated/xtreemfs/MRCServiceConstants.h b/cpp/generated/xtreemfs/MRCServiceConstants.h new file mode 100644 index 0000000..f2017de --- /dev/null +++ b/cpp/generated/xtreemfs/MRCServiceConstants.h @@ -0,0 +1,57 @@ +//automatically generated from MRC.proto at Thu Dec 11 16:09:40 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef MRCSERVICECONSTANTS_H_ +#define MRCSERVICECONSTANTS_H_ +#include + +namespace xtreemfs { +namespace pbrpc { + +const uint32_t INTERFACE_ID_MRC = 20001; +const uint32_t PROC_ID_FSETATTR = 2; +const uint32_t PROC_ID_FTRUNCATE = 3; +const uint32_t PROC_ID_GETATTR = 4; +const uint32_t PROC_ID_GETXATTR = 5; +const uint32_t PROC_ID_LINK = 6; +const uint32_t PROC_ID_LISTXATTR = 7; +const uint32_t PROC_ID_MKDIR = 8; +const uint32_t PROC_ID_OPEN = 9; +const uint32_t PROC_ID_READDIR = 10; +const uint32_t PROC_ID_READLINK = 11; +const uint32_t PROC_ID_REMOVEXATTR = 12; +const uint32_t PROC_ID_RENAME = 13; +const uint32_t PROC_ID_RMDIR = 14; +const uint32_t PROC_ID_SETATTR = 15; +const uint32_t PROC_ID_SETXATTR = 16; +const uint32_t PROC_ID_STATVFS = 17; +const uint32_t PROC_ID_SYMLINK = 18; +const uint32_t PROC_ID_UNLINK = 19; +const uint32_t PROC_ID_ACCESS = 20; +const uint32_t PROC_ID_XTREEMFS_CHECKPOINT = 30; +const uint32_t PROC_ID_XTREEMFS_CHECK_FILE_EXISTS = 31; +const uint32_t PROC_ID_XTREEMFS_DUMP_DATABASE = 32; +const uint32_t PROC_ID_XTREEMFS_GET_SUITABLE_OSDS = 33; +const uint32_t PROC_ID_XTREEMFS_INTERNAL_DEBUG = 34; +const uint32_t PROC_ID_XTREEMFS_LISTDIR = 35; +const uint32_t PROC_ID_XTREEMFS_LSVOL = 36; +const uint32_t PROC_ID_XTREEMFS_MKVOL = 47; +const uint32_t PROC_ID_XTREEMFS_RENEW_CAPABILITY = 37; +const uint32_t PROC_ID_XTREEMFS_REPLICATION_TO_MASTER = 38; +const uint32_t PROC_ID_XTREEMFS_REPLICA_ADD = 39; +const uint32_t PROC_ID_XTREEMFS_REPLICA_LIST = 40; +const uint32_t PROC_ID_XTREEMFS_REPLICA_REMOVE = 41; +const uint32_t PROC_ID_XTREEMFS_RESTORE_DATABASE = 42; +const uint32_t PROC_ID_XTREEMFS_RESTORE_FILE = 43; +const uint32_t PROC_ID_XTREEMFS_RMVOL = 44; +const uint32_t PROC_ID_XTREEMFS_SHUTDOWN = 45; +const uint32_t PROC_ID_XTREEMFS_UPDATE_FILE_SIZE = 46; +const uint32_t PROC_ID_XTREEMFS_SET_REPLICA_UPDATE_POLICY = 48; +const uint32_t PROC_ID_XTREEMFS_SET_READ_ONLY_XATTR = 49; +const uint32_t PROC_ID_XTREEMFS_GET_FILE_CREDENTIALS = 50; +const uint32_t PROC_ID_XTREEMFS_GET_XLOCSET = 51; + +} // namespace pbrpc +} // namespace xtreemfs + +#endif // MRCSERVICECLIENT_H_ diff --git a/cpp/generated/xtreemfs/OSD.pb.cc b/cpp/generated/xtreemfs/OSD.pb.cc new file mode 100644 index 0000000..7de087f --- /dev/null +++ b/cpp/generated/xtreemfs/OSD.pb.cc @@ -0,0 +1,13946 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: xtreemfs/OSD.proto + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "xtreemfs/OSD.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +namespace { + +const ::google::protobuf::Descriptor* InternalGmax_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InternalGmax_reflection_ = NULL; +const ::google::protobuf::Descriptor* Lock_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Lock_reflection_ = NULL; +const ::google::protobuf::Descriptor* ObjectData_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ObjectData_reflection_ = NULL; +const ::google::protobuf::Descriptor* ObjectList_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ObjectList_reflection_ = NULL; +const ::google::protobuf::Descriptor* ObjectVersion_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ObjectVersion_reflection_ = NULL; +const ::google::protobuf::Descriptor* TruncateRecord_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + TruncateRecord_reflection_ = NULL; +const ::google::protobuf::Descriptor* TruncateLog_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + TruncateLog_reflection_ = NULL; +const ::google::protobuf::Descriptor* XLocSetVersionState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + XLocSetVersionState_reflection_ = NULL; +const ::google::protobuf::Descriptor* ReplicaStatus_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ReplicaStatus_reflection_ = NULL; +const ::google::protobuf::Descriptor* ObjectVersionMapping_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ObjectVersionMapping_reflection_ = NULL; +const ::google::protobuf::Descriptor* AuthoritativeReplicaState_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AuthoritativeReplicaState_reflection_ = NULL; +const ::google::protobuf::Descriptor* InternalReadLocalResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + InternalReadLocalResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* readRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + readRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* truncateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + truncateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* unlink_osd_Request_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + unlink_osd_Request_reflection_ = NULL; +const ::google::protobuf::Descriptor* writeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + writeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_broadcast_gmaxRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_broadcast_gmaxRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_check_objectRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_check_objectRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_cleanup_get_resultsResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_cleanup_get_resultsResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_cleanup_is_runningResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_cleanup_is_runningResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_cleanup_startRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_cleanup_startRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_cleanup_statusResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_cleanup_statusResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rwr_fetchRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rwr_fetchRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_repair_objectRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_repair_objectRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rwr_flease_msgRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rwr_flease_msgRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rwr_set_primary_epochRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rwr_set_primary_epochRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rwr_statusRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rwr_statusRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rwr_truncateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rwr_truncateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rwr_updateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rwr_updateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_internal_get_gmaxRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_internal_get_gmaxRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_internal_get_file_sizeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_internal_get_file_sizeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_internal_get_file_sizeResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_internal_get_file_sizeResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_internal_read_localRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_internal_read_localRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_internal_get_object_setRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_internal_get_object_setRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_internal_get_fileid_listResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_internal_get_fileid_listResponse_reflection_ = NULL; +const ::google::protobuf::Descriptor* lockRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + lockRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_pingMesssage_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_pingMesssage_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rwr_auth_stateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rwr_auth_stateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_rwr_reset_completeRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_rwr_reset_completeRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_xloc_set_invalidateRequest_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_xloc_set_invalidateRequest_reflection_ = NULL; +const ::google::protobuf::Descriptor* xtreemfs_xloc_set_invalidateResponse_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + xtreemfs_xloc_set_invalidateResponse_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* OSDHealthResult_descriptor_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto() { + protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "xtreemfs/OSD.proto"); + GOOGLE_CHECK(file != NULL); + InternalGmax_descriptor_ = file->message_type(0); + static const int InternalGmax_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, epoch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, file_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, last_object_id_), + }; + InternalGmax_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + InternalGmax_descriptor_, + InternalGmax::default_instance_, + InternalGmax_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(InternalGmax)); + Lock_descriptor_ = file->message_type(1); + static const int Lock_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, client_pid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, client_uuid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, offset_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, exclusive_), + }; + Lock_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Lock_descriptor_, + Lock::default_instance_, + Lock_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Lock)); + ObjectData_descriptor_ = file->message_type(2); + static const int ObjectData_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, checksum_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, invalid_checksum_on_osd_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, zero_padding_), + }; + ObjectData_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ObjectData_descriptor_, + ObjectData::default_instance_, + ObjectData_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ObjectData)); + ObjectList_descriptor_ = file->message_type(3); + static const int ObjectList_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, set_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, stripe_width_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, first__), + }; + ObjectList_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ObjectList_descriptor_, + ObjectList::default_instance_, + ObjectList_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ObjectList)); + ObjectVersion_descriptor_ = file->message_type(4); + static const int ObjectVersion_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersion, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersion, object_version_), + }; + ObjectVersion_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ObjectVersion_descriptor_, + ObjectVersion::default_instance_, + ObjectVersion_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersion, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersion, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ObjectVersion)); + TruncateRecord_descriptor_ = file->message_type(5); + static const int TruncateRecord_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateRecord, version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateRecord, last_object_number_), + }; + TruncateRecord_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + TruncateRecord_descriptor_, + TruncateRecord::default_instance_, + TruncateRecord_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateRecord, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateRecord, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(TruncateRecord)); + TruncateLog_descriptor_ = file->message_type(6); + static const int TruncateLog_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateLog, records_), + }; + TruncateLog_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + TruncateLog_descriptor_, + TruncateLog::default_instance_, + TruncateLog_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateLog, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateLog, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(TruncateLog)); + XLocSetVersionState_descriptor_ = file->message_type(7); + static const int XLocSetVersionState_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, invalidated_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, modified_time_), + }; + XLocSetVersionState_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + XLocSetVersionState_descriptor_, + XLocSetVersionState::default_instance_, + XLocSetVersionState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(XLocSetVersionState)); + ReplicaStatus_descriptor_ = file->message_type(8); + static const int ReplicaStatus_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, truncate_epoch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, file_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, max_obj_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, primary_epoch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, objectversions_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, truncate_log_), + }; + ReplicaStatus_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ReplicaStatus_descriptor_, + ReplicaStatus::default_instance_, + ReplicaStatus_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ReplicaStatus)); + ObjectVersionMapping_descriptor_ = file->message_type(9); + static const int ObjectVersionMapping_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, object_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, osd_uuids_), + }; + ObjectVersionMapping_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ObjectVersionMapping_descriptor_, + ObjectVersionMapping::default_instance_, + ObjectVersionMapping_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ObjectVersionMapping)); + AuthoritativeReplicaState_descriptor_ = file->message_type(10); + static const int AuthoritativeReplicaState_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, truncate_epoch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, max_obj_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, objectversions_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, truncate_log_), + }; + AuthoritativeReplicaState_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AuthoritativeReplicaState_descriptor_, + AuthoritativeReplicaState::default_instance_, + AuthoritativeReplicaState_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AuthoritativeReplicaState)); + InternalReadLocalResponse_descriptor_ = file->message_type(11); + static const int InternalReadLocalResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalReadLocalResponse, data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalReadLocalResponse, object_set_), + }; + InternalReadLocalResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + InternalReadLocalResponse_descriptor_, + InternalReadLocalResponse::default_instance_, + InternalReadLocalResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalReadLocalResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalReadLocalResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(InternalReadLocalResponse)); + readRequest_descriptor_ = file->message_type(12); + static const int readRequest_offsets_[6] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, object_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, offset_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, length_), + }; + readRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + readRequest_descriptor_, + readRequest::default_instance_, + readRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(readRequest)); + truncateRequest_descriptor_ = file->message_type(13); + static const int truncateRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, new_file_size_), + }; + truncateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + truncateRequest_descriptor_, + truncateRequest::default_instance_, + truncateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(truncateRequest)); + unlink_osd_Request_descriptor_ = file->message_type(14); + static const int unlink_osd_Request_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlink_osd_Request, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlink_osd_Request, file_id_), + }; + unlink_osd_Request_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + unlink_osd_Request_descriptor_, + unlink_osd_Request::default_instance_, + unlink_osd_Request_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlink_osd_Request, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlink_osd_Request, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(unlink_osd_Request)); + writeRequest_descriptor_ = file->message_type(15); + static const int writeRequest_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, object_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, offset_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, lease_timeout_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, object_data_), + }; + writeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + writeRequest_descriptor_, + writeRequest::default_instance_, + writeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(writeRequest)); + xtreemfs_broadcast_gmaxRequest_descriptor_ = file->message_type(16); + static const int xtreemfs_broadcast_gmaxRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, truncate_epoch_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, last_object_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, file_size_), + }; + xtreemfs_broadcast_gmaxRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_broadcast_gmaxRequest_descriptor_, + xtreemfs_broadcast_gmaxRequest::default_instance_, + xtreemfs_broadcast_gmaxRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_broadcast_gmaxRequest)); + xtreemfs_check_objectRequest_descriptor_ = file->message_type(17); + static const int xtreemfs_check_objectRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, object_version_), + }; + xtreemfs_check_objectRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_check_objectRequest_descriptor_, + xtreemfs_check_objectRequest::default_instance_, + xtreemfs_check_objectRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_check_objectRequest)); + xtreemfs_cleanup_get_resultsResponse_descriptor_ = file->message_type(18); + static const int xtreemfs_cleanup_get_resultsResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_get_resultsResponse, results_), + }; + xtreemfs_cleanup_get_resultsResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_cleanup_get_resultsResponse_descriptor_, + xtreemfs_cleanup_get_resultsResponse::default_instance_, + xtreemfs_cleanup_get_resultsResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_get_resultsResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_get_resultsResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_cleanup_get_resultsResponse)); + xtreemfs_cleanup_is_runningResponse_descriptor_ = file->message_type(19); + static const int xtreemfs_cleanup_is_runningResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_is_runningResponse, is_running_), + }; + xtreemfs_cleanup_is_runningResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_cleanup_is_runningResponse_descriptor_, + xtreemfs_cleanup_is_runningResponse::default_instance_, + xtreemfs_cleanup_is_runningResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_is_runningResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_is_runningResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_cleanup_is_runningResponse)); + xtreemfs_cleanup_startRequest_descriptor_ = file->message_type(20); + static const int xtreemfs_cleanup_startRequest_offsets_[5] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, remove_zombies_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, remove_unavail_volume_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, lost_and_found_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, delete_metadata_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, metadata_timeout_), + }; + xtreemfs_cleanup_startRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_cleanup_startRequest_descriptor_, + xtreemfs_cleanup_startRequest::default_instance_, + xtreemfs_cleanup_startRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_cleanup_startRequest)); + xtreemfs_cleanup_statusResponse_descriptor_ = file->message_type(21); + static const int xtreemfs_cleanup_statusResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_statusResponse, status_), + }; + xtreemfs_cleanup_statusResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_cleanup_statusResponse_descriptor_, + xtreemfs_cleanup_statusResponse::default_instance_, + xtreemfs_cleanup_statusResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_statusResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_statusResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_cleanup_statusResponse)); + xtreemfs_rwr_fetchRequest_descriptor_ = file->message_type(22); + static const int xtreemfs_rwr_fetchRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, object_version_), + }; + xtreemfs_rwr_fetchRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rwr_fetchRequest_descriptor_, + xtreemfs_rwr_fetchRequest::default_instance_, + xtreemfs_rwr_fetchRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rwr_fetchRequest)); + xtreemfs_repair_objectRequest_descriptor_ = file->message_type(23); + static const int xtreemfs_repair_objectRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, object_version_), + }; + xtreemfs_repair_objectRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_repair_objectRequest_descriptor_, + xtreemfs_repair_objectRequest::default_instance_, + xtreemfs_repair_objectRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_repair_objectRequest)); + xtreemfs_rwr_flease_msgRequest_descriptor_ = file->message_type(24); + static const int xtreemfs_rwr_flease_msgRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_flease_msgRequest, sender_hostname_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_flease_msgRequest, sender_port_), + }; + xtreemfs_rwr_flease_msgRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rwr_flease_msgRequest_descriptor_, + xtreemfs_rwr_flease_msgRequest::default_instance_, + xtreemfs_rwr_flease_msgRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_flease_msgRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_flease_msgRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rwr_flease_msgRequest)); + xtreemfs_rwr_set_primary_epochRequest_descriptor_ = file->message_type(25); + static const int xtreemfs_rwr_set_primary_epochRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, primary_epoch_), + }; + xtreemfs_rwr_set_primary_epochRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rwr_set_primary_epochRequest_descriptor_, + xtreemfs_rwr_set_primary_epochRequest::default_instance_, + xtreemfs_rwr_set_primary_epochRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rwr_set_primary_epochRequest)); + xtreemfs_rwr_statusRequest_descriptor_ = file->message_type(26); + static const int xtreemfs_rwr_statusRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, max_local_obj_version_), + }; + xtreemfs_rwr_statusRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rwr_statusRequest_descriptor_, + xtreemfs_rwr_statusRequest::default_instance_, + xtreemfs_rwr_statusRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rwr_statusRequest)); + xtreemfs_rwr_truncateRequest_descriptor_ = file->message_type(27); + static const int xtreemfs_rwr_truncateRequest_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, new_file_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, object_version_), + }; + xtreemfs_rwr_truncateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rwr_truncateRequest_descriptor_, + xtreemfs_rwr_truncateRequest::default_instance_, + xtreemfs_rwr_truncateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rwr_truncateRequest)); + xtreemfs_rwr_updateRequest_descriptor_ = file->message_type(28); + static const int xtreemfs_rwr_updateRequest_offsets_[7] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, new_file_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, object_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, offset_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, obj_), + }; + xtreemfs_rwr_updateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rwr_updateRequest_descriptor_, + xtreemfs_rwr_updateRequest::default_instance_, + xtreemfs_rwr_updateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rwr_updateRequest)); + xtreemfs_internal_get_gmaxRequest_descriptor_ = file->message_type(29); + static const int xtreemfs_internal_get_gmaxRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_gmaxRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_gmaxRequest, file_id_), + }; + xtreemfs_internal_get_gmaxRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_internal_get_gmaxRequest_descriptor_, + xtreemfs_internal_get_gmaxRequest::default_instance_, + xtreemfs_internal_get_gmaxRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_gmaxRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_gmaxRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_internal_get_gmaxRequest)); + xtreemfs_internal_get_file_sizeRequest_descriptor_ = file->message_type(30); + static const int xtreemfs_internal_get_file_sizeRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeRequest, file_id_), + }; + xtreemfs_internal_get_file_sizeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_internal_get_file_sizeRequest_descriptor_, + xtreemfs_internal_get_file_sizeRequest::default_instance_, + xtreemfs_internal_get_file_sizeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_internal_get_file_sizeRequest)); + xtreemfs_internal_get_file_sizeResponse_descriptor_ = file->message_type(31); + static const int xtreemfs_internal_get_file_sizeResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeResponse, file_size_), + }; + xtreemfs_internal_get_file_sizeResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_internal_get_file_sizeResponse_descriptor_, + xtreemfs_internal_get_file_sizeResponse::default_instance_, + xtreemfs_internal_get_file_sizeResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_internal_get_file_sizeResponse)); + xtreemfs_internal_read_localRequest_descriptor_ = file->message_type(32); + static const int xtreemfs_internal_read_localRequest_offsets_[8] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, object_number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, object_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, offset_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, attach_object_list_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, required_objects_), + }; + xtreemfs_internal_read_localRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_internal_read_localRequest_descriptor_, + xtreemfs_internal_read_localRequest::default_instance_, + xtreemfs_internal_read_localRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_internal_read_localRequest)); + xtreemfs_internal_get_object_setRequest_descriptor_ = file->message_type(33); + static const int xtreemfs_internal_get_object_setRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_object_setRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_object_setRequest, file_id_), + }; + xtreemfs_internal_get_object_setRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_internal_get_object_setRequest_descriptor_, + xtreemfs_internal_get_object_setRequest::default_instance_, + xtreemfs_internal_get_object_setRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_object_setRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_object_setRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_internal_get_object_setRequest)); + xtreemfs_internal_get_fileid_listResponse_descriptor_ = file->message_type(34); + static const int xtreemfs_internal_get_fileid_listResponse_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_fileid_listResponse, file_ids_), + }; + xtreemfs_internal_get_fileid_listResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_internal_get_fileid_listResponse_descriptor_, + xtreemfs_internal_get_fileid_listResponse::default_instance_, + xtreemfs_internal_get_fileid_listResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_fileid_listResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_fileid_listResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_internal_get_fileid_listResponse)); + lockRequest_descriptor_ = file->message_type(35); + static const int lockRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(lockRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(lockRequest, lock_request_), + }; + lockRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + lockRequest_descriptor_, + lockRequest::default_instance_, + lockRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(lockRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(lockRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(lockRequest)); + xtreemfs_pingMesssage_descriptor_ = file->message_type(36); + static const int xtreemfs_pingMesssage_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_pingMesssage, coordinates_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_pingMesssage, request_response_), + }; + xtreemfs_pingMesssage_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_pingMesssage_descriptor_, + xtreemfs_pingMesssage::default_instance_, + xtreemfs_pingMesssage_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_pingMesssage, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_pingMesssage, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_pingMesssage)); + xtreemfs_rwr_auth_stateRequest_descriptor_ = file->message_type(37); + static const int xtreemfs_rwr_auth_stateRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, state_), + }; + xtreemfs_rwr_auth_stateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rwr_auth_stateRequest_descriptor_, + xtreemfs_rwr_auth_stateRequest::default_instance_, + xtreemfs_rwr_auth_stateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rwr_auth_stateRequest)); + xtreemfs_rwr_reset_completeRequest_descriptor_ = file->message_type(38); + static const int xtreemfs_rwr_reset_completeRequest_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, file_id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, primary_epoch_), + }; + xtreemfs_rwr_reset_completeRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_rwr_reset_completeRequest_descriptor_, + xtreemfs_rwr_reset_completeRequest::default_instance_, + xtreemfs_rwr_reset_completeRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_rwr_reset_completeRequest)); + xtreemfs_xloc_set_invalidateRequest_descriptor_ = file->message_type(39); + static const int xtreemfs_xloc_set_invalidateRequest_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateRequest, file_credentials_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateRequest, file_id_), + }; + xtreemfs_xloc_set_invalidateRequest_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_xloc_set_invalidateRequest_descriptor_, + xtreemfs_xloc_set_invalidateRequest::default_instance_, + xtreemfs_xloc_set_invalidateRequest_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateRequest, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateRequest, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_xloc_set_invalidateRequest)); + xtreemfs_xloc_set_invalidateResponse_descriptor_ = file->message_type(40); + static const int xtreemfs_xloc_set_invalidateResponse_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateResponse, lease_state_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateResponse, replica_status_), + }; + xtreemfs_xloc_set_invalidateResponse_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + xtreemfs_xloc_set_invalidateResponse_descriptor_, + xtreemfs_xloc_set_invalidateResponse::default_instance_, + xtreemfs_xloc_set_invalidateResponse_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateResponse, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateResponse, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(xtreemfs_xloc_set_invalidateResponse)); + OSDHealthResult_descriptor_ = file->enum_type(0); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_xtreemfs_2fOSD_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InternalGmax_descriptor_, &InternalGmax::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Lock_descriptor_, &Lock::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ObjectData_descriptor_, &ObjectData::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ObjectList_descriptor_, &ObjectList::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ObjectVersion_descriptor_, &ObjectVersion::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + TruncateRecord_descriptor_, &TruncateRecord::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + TruncateLog_descriptor_, &TruncateLog::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + XLocSetVersionState_descriptor_, &XLocSetVersionState::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ReplicaStatus_descriptor_, &ReplicaStatus::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ObjectVersionMapping_descriptor_, &ObjectVersionMapping::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AuthoritativeReplicaState_descriptor_, &AuthoritativeReplicaState::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + InternalReadLocalResponse_descriptor_, &InternalReadLocalResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + readRequest_descriptor_, &readRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + truncateRequest_descriptor_, &truncateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + unlink_osd_Request_descriptor_, &unlink_osd_Request::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + writeRequest_descriptor_, &writeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_broadcast_gmaxRequest_descriptor_, &xtreemfs_broadcast_gmaxRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_check_objectRequest_descriptor_, &xtreemfs_check_objectRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_cleanup_get_resultsResponse_descriptor_, &xtreemfs_cleanup_get_resultsResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_cleanup_is_runningResponse_descriptor_, &xtreemfs_cleanup_is_runningResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_cleanup_startRequest_descriptor_, &xtreemfs_cleanup_startRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_cleanup_statusResponse_descriptor_, &xtreemfs_cleanup_statusResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rwr_fetchRequest_descriptor_, &xtreemfs_rwr_fetchRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_repair_objectRequest_descriptor_, &xtreemfs_repair_objectRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rwr_flease_msgRequest_descriptor_, &xtreemfs_rwr_flease_msgRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rwr_set_primary_epochRequest_descriptor_, &xtreemfs_rwr_set_primary_epochRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rwr_statusRequest_descriptor_, &xtreemfs_rwr_statusRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rwr_truncateRequest_descriptor_, &xtreemfs_rwr_truncateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rwr_updateRequest_descriptor_, &xtreemfs_rwr_updateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_internal_get_gmaxRequest_descriptor_, &xtreemfs_internal_get_gmaxRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_internal_get_file_sizeRequest_descriptor_, &xtreemfs_internal_get_file_sizeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_internal_get_file_sizeResponse_descriptor_, &xtreemfs_internal_get_file_sizeResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_internal_read_localRequest_descriptor_, &xtreemfs_internal_read_localRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_internal_get_object_setRequest_descriptor_, &xtreemfs_internal_get_object_setRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_internal_get_fileid_listResponse_descriptor_, &xtreemfs_internal_get_fileid_listResponse::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + lockRequest_descriptor_, &lockRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_pingMesssage_descriptor_, &xtreemfs_pingMesssage::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rwr_auth_stateRequest_descriptor_, &xtreemfs_rwr_auth_stateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_rwr_reset_completeRequest_descriptor_, &xtreemfs_rwr_reset_completeRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_xloc_set_invalidateRequest_descriptor_, &xtreemfs_xloc_set_invalidateRequest::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + xtreemfs_xloc_set_invalidateResponse_descriptor_, &xtreemfs_xloc_set_invalidateResponse::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto() { + delete InternalGmax::default_instance_; + delete InternalGmax_reflection_; + delete Lock::default_instance_; + delete Lock_reflection_; + delete ObjectData::default_instance_; + delete ObjectData_reflection_; + delete ObjectList::default_instance_; + delete ObjectList_reflection_; + delete ObjectVersion::default_instance_; + delete ObjectVersion_reflection_; + delete TruncateRecord::default_instance_; + delete TruncateRecord_reflection_; + delete TruncateLog::default_instance_; + delete TruncateLog_reflection_; + delete XLocSetVersionState::default_instance_; + delete XLocSetVersionState_reflection_; + delete ReplicaStatus::default_instance_; + delete ReplicaStatus_reflection_; + delete ObjectVersionMapping::default_instance_; + delete ObjectVersionMapping_reflection_; + delete AuthoritativeReplicaState::default_instance_; + delete AuthoritativeReplicaState_reflection_; + delete InternalReadLocalResponse::default_instance_; + delete InternalReadLocalResponse_reflection_; + delete readRequest::default_instance_; + delete readRequest_reflection_; + delete truncateRequest::default_instance_; + delete truncateRequest_reflection_; + delete unlink_osd_Request::default_instance_; + delete unlink_osd_Request_reflection_; + delete writeRequest::default_instance_; + delete writeRequest_reflection_; + delete xtreemfs_broadcast_gmaxRequest::default_instance_; + delete xtreemfs_broadcast_gmaxRequest_reflection_; + delete xtreemfs_check_objectRequest::default_instance_; + delete xtreemfs_check_objectRequest_reflection_; + delete xtreemfs_cleanup_get_resultsResponse::default_instance_; + delete xtreemfs_cleanup_get_resultsResponse_reflection_; + delete xtreemfs_cleanup_is_runningResponse::default_instance_; + delete xtreemfs_cleanup_is_runningResponse_reflection_; + delete xtreemfs_cleanup_startRequest::default_instance_; + delete xtreemfs_cleanup_startRequest_reflection_; + delete xtreemfs_cleanup_statusResponse::default_instance_; + delete xtreemfs_cleanup_statusResponse_reflection_; + delete xtreemfs_rwr_fetchRequest::default_instance_; + delete xtreemfs_rwr_fetchRequest_reflection_; + delete xtreemfs_repair_objectRequest::default_instance_; + delete xtreemfs_repair_objectRequest_reflection_; + delete xtreemfs_rwr_flease_msgRequest::default_instance_; + delete xtreemfs_rwr_flease_msgRequest_reflection_; + delete xtreemfs_rwr_set_primary_epochRequest::default_instance_; + delete xtreemfs_rwr_set_primary_epochRequest_reflection_; + delete xtreemfs_rwr_statusRequest::default_instance_; + delete xtreemfs_rwr_statusRequest_reflection_; + delete xtreemfs_rwr_truncateRequest::default_instance_; + delete xtreemfs_rwr_truncateRequest_reflection_; + delete xtreemfs_rwr_updateRequest::default_instance_; + delete xtreemfs_rwr_updateRequest_reflection_; + delete xtreemfs_internal_get_gmaxRequest::default_instance_; + delete xtreemfs_internal_get_gmaxRequest_reflection_; + delete xtreemfs_internal_get_file_sizeRequest::default_instance_; + delete xtreemfs_internal_get_file_sizeRequest_reflection_; + delete xtreemfs_internal_get_file_sizeResponse::default_instance_; + delete xtreemfs_internal_get_file_sizeResponse_reflection_; + delete xtreemfs_internal_read_localRequest::default_instance_; + delete xtreemfs_internal_read_localRequest_reflection_; + delete xtreemfs_internal_get_object_setRequest::default_instance_; + delete xtreemfs_internal_get_object_setRequest_reflection_; + delete xtreemfs_internal_get_fileid_listResponse::default_instance_; + delete xtreemfs_internal_get_fileid_listResponse_reflection_; + delete lockRequest::default_instance_; + delete lockRequest_reflection_; + delete xtreemfs_pingMesssage::default_instance_; + delete xtreemfs_pingMesssage_reflection_; + delete xtreemfs_rwr_auth_stateRequest::default_instance_; + delete xtreemfs_rwr_auth_stateRequest_reflection_; + delete xtreemfs_rwr_reset_completeRequest::default_instance_; + delete xtreemfs_rwr_reset_completeRequest_reflection_; + delete xtreemfs_xloc_set_invalidateRequest::default_instance_; + delete xtreemfs_xloc_set_invalidateRequest_reflection_; + delete xtreemfs_xloc_set_invalidateResponse::default_instance_; + delete xtreemfs_xloc_set_invalidateResponse_reflection_; +} + +void protobuf_AddDesc_xtreemfs_2fOSD_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fPBRPC_2eproto(); + ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fCommon_2eproto(); + ::xtreemfs::pbrpc::protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\022xtreemfs/OSD.proto\022\016xtreemfs.pbrpc\032\023in" + "clude/PBRPC.proto\032\024include/Common.proto\032" + "\032xtreemfs/GlobalTypes.proto\"H\n\014InternalG" + "max\022\r\n\005epoch\030\001 \002(\006\022\021\n\tfile_size\030\002 \002(\006\022\026\n" + "\016last_object_id\030\003 \002(\006\"b\n\004Lock\022\022\n\nclient_" + "pid\030\001 \002(\007\022\023\n\013client_uuid\030\002 \002(\t\022\016\n\006length" + "\030\003 \002(\006\022\016\n\006offset\030\004 \002(\006\022\021\n\texclusive\030\005 \002(" + "\010\"U\n\nObjectData\022\020\n\010checksum\030\001 \002(\007\022\037\n\027inv" + "alid_checksum_on_osd\030\002 \002(\010\022\024\n\014zero_paddi" + "ng\030\003 \002(\007\"\?\n\nObjectList\022\013\n\003set\030\001 \002(\014\022\024\n\014s" + "tripe_width\030\002 \002(\007\022\016\n\006first_\030\003 \002(\007\">\n\rObj" + "ectVersion\022\025\n\robject_number\030\001 \002(\006\022\026\n\016obj" + "ect_version\030\002 \002(\006\"=\n\016TruncateRecord\022\017\n\007v" + "ersion\030\001 \002(\006\022\032\n\022last_object_number\030\002 \002(\006" + "\">\n\013TruncateLog\022/\n\007records\030\001 \003(\0132\036.xtree" + "mfs.pbrpc.TruncateRecord\"R\n\023XLocSetVersi" + "onState\022\017\n\007version\030\001 \002(\007\022\023\n\013invalidated\030" + "\002 \002(\010\022\025\n\rmodified_time\030\003 \001(\006\"\324\001\n\rReplica" + "Status\022\026\n\016truncate_epoch\030\001 \002(\006\022\021\n\tfile_s" + "ize\030\002 \002(\006\022\027\n\017max_obj_version\030\003 \002(\006\022\025\n\rpr" + "imary_epoch\030\004 \002(\007\0225\n\016objectVersions\030\005 \003(" + "\0132\035.xtreemfs.pbrpc.ObjectVersion\0221\n\014trun" + "cate_log\030\006 \002(\0132\033.xtreemfs.pbrpc.Truncate" + "Log\"X\n\024ObjectVersionMapping\022\025\n\robject_nu" + "mber\030\001 \002(\006\022\026\n\016object_version\030\002 \002(\006\022\021\n\tos" + "d_uuids\030\003 \003(\t\"\275\001\n\031AuthoritativeReplicaSt" + "ate\022\026\n\016truncate_epoch\030\001 \002(\006\022\027\n\017max_obj_v" + "ersion\030\004 \002(\006\022<\n\016objectVersions\030\002 \003(\0132$.x" + "treemfs.pbrpc.ObjectVersionMapping\0221\n\014tr" + "uncate_log\030\003 \002(\0132\033.xtreemfs.pbrpc.Trunca" + "teLog\"u\n\031InternalReadLocalResponse\022(\n\004da" + "ta\030\001 \002(\0132\032.xtreemfs.pbrpc.ObjectData\022.\n\n" + "object_set\030\002 \003(\0132\032.xtreemfs.pbrpc.Object" + "List\"\250\001\n\013readRequest\0229\n\020file_credentials" + "\030\001 \002(\0132\037.xtreemfs.pbrpc.FileCredentials\022" + "\017\n\007file_id\030\002 \002(\t\022\025\n\robject_number\030\003 \002(\006\022" + "\026\n\016object_version\030\004 \002(\006\022\016\n\006offset\030\005 \002(\007\022" + "\016\n\006length\030\006 \002(\007\"t\n\017truncateRequest\0229\n\020fi" + "le_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc.Fi" + "leCredentials\022\017\n\007file_id\030\002 \002(\t\022\025\n\rnew_fi" + "le_size\030\003 \002(\006\"`\n\022unlink_osd_Request\0229\n\020f" + "ile_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc.F" + "ileCredentials\022\017\n\007file_id\030\002 \002(\t\"\341\001\n\014writ" + "eRequest\0229\n\020file_credentials\030\001 \002(\0132\037.xtr" + "eemfs.pbrpc.FileCredentials\022\017\n\007file_id\030\002" + " \002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016object_ve" + "rsion\030\004 \002(\006\022\016\n\006offset\030\005 \002(\007\022\025\n\rlease_tim" + "eout\030\006 \002(\006\022/\n\013object_data\030\007 \002(\0132\032.xtreem" + "fs.pbrpc.ObjectData\"q\n\036xtreemfs_broadcas" + "t_gmaxRequest\022\017\n\007file_id\030\001 \002(\t\022\026\n\016trunca" + "te_epoch\030\002 \002(\006\022\023\n\013last_object\030\003 \002(\006\022\021\n\tf" + "ile_size\030\004 \002(\006\"\231\001\n\034xtreemfs_check_object" + "Request\0229\n\020file_credentials\030\001 \002(\0132\037.xtre" + "emfs.pbrpc.FileCredentials\022\017\n\007file_id\030\002 " + "\002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016object_ver" + "sion\030\004 \002(\006\"7\n$xtreemfs_cleanup_get_resul" + "tsResponse\022\017\n\007results\030\001 \003(\t\"9\n#xtreemfs_" + "cleanup_is_runningResponse\022\022\n\nis_running" + "\030\001 \002(\010\"\241\001\n\035xtreemfs_cleanup_startRequest" + "\022\026\n\016remove_zombies\030\001 \002(\010\022\035\n\025remove_unava" + "il_volume\030\002 \002(\010\022\026\n\016lost_and_found\030\003 \002(\010\022" + "\027\n\017delete_metadata\030\004 \002(\010\022\030\n\020metadata_tim" + "eout\030\005 \002(\007\"1\n\037xtreemfs_cleanup_statusRes" + "ponse\022\016\n\006status\030\001 \002(\t\"\226\001\n\031xtreemfs_rwr_f" + "etchRequest\0229\n\020file_credentials\030\001 \002(\0132\037." + "xtreemfs.pbrpc.FileCredentials\022\017\n\007file_i" + "d\030\002 \002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016object" + "_version\030\004 \002(\006\"\232\001\n\035xtreemfs_repair_objec" + "tRequest\0229\n\020file_credentials\030\001 \002(\0132\037.xtr" + "eemfs.pbrpc.FileCredentials\022\017\n\007file_id\030\002" + " \002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016object_ve" + "rsion\030\004 \002(\006\"N\n\036xtreemfs_rwr_flease_msgRe" + "quest\022\027\n\017sender_hostname\030\001 \002(\t\022\023\n\013sender" + "_port\030\002 \002(\007\"\212\001\n%xtreemfs_rwr_set_primary" + "_epochRequest\0229\n\020file_credentials\030\001 \002(\0132" + "\037.xtreemfs.pbrpc.FileCredentials\022\017\n\007file" + "_id\030\002 \002(\t\022\025\n\rprimary_epoch\030\003 \002(\007\"\207\001\n\032xtr" + "eemfs_rwr_statusRequest\0229\n\020file_credenti" + "als\030\001 \002(\0132\037.xtreemfs.pbrpc.FileCredentia" + "ls\022\017\n\007file_id\030\002 \002(\t\022\035\n\025max_local_obj_ver" + "sion\030\003 \002(\006\"\231\001\n\034xtreemfs_rwr_truncateRequ" + "est\0229\n\020file_credentials\030\001 \002(\0132\037.xtreemfs" + ".pbrpc.FileCredentials\022\017\n\007file_id\030\002 \002(\t\022" + "\025\n\rnew_file_size\030\003 \002(\006\022\026\n\016object_version" + "\030\004 \002(\006\"\347\001\n\032xtreemfs_rwr_updateRequest\0229\n" + "\020file_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc" + ".FileCredentials\022\017\n\007file_id\030\002 \002(\t\022\025\n\rnew" + "_file_size\030\003 \002(\006\022\025\n\robject_number\030\007 \002(\006\022" + "\026\n\016object_version\030\004 \002(\006\022\016\n\006offset\030\005 \002(\007\022" + "\'\n\003obj\030\006 \002(\0132\032.xtreemfs.pbrpc.ObjectData" + "\"o\n!xtreemfs_internal_get_gmaxRequest\0229\n" + "\020file_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc" + ".FileCredentials\022\017\n\007file_id\030\002 \002(\t\"t\n&xtr" + "eemfs_internal_get_file_sizeRequest\0229\n\020f" + "ile_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc.F" + "ileCredentials\022\017\n\007file_id\030\002 \002(\t\"<\n\'xtree" + "mfs_internal_get_file_sizeResponse\022\021\n\tfi" + "le_size\030\001 \002(\006\"\222\002\n#xtreemfs_internal_read" + "_localRequest\0229\n\020file_credentials\030\001 \002(\0132" + "\037.xtreemfs.pbrpc.FileCredentials\022\017\n\007file" + "_id\030\002 \002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016obje" + "ct_version\030\004 \002(\006\022\016\n\006offset\030\005 \002(\007\022\016\n\006leng" + "th\030\006 \002(\007\022\032\n\022attach_object_list\030\007 \002(\010\0224\n\020" + "required_objects\030\010 \003(\0132\032.xtreemfs.pbrpc." + "ObjectList\"u\n\'xtreemfs_internal_get_obje" + "ct_setRequest\0229\n\020file_credentials\030\001 \002(\0132" + "\037.xtreemfs.pbrpc.FileCredentials\022\017\n\007file" + "_id\030\002 \002(\t\"=\n)xtreemfs_internal_get_filei" + "d_listResponse\022\020\n\010file_ids\030\001 \003(\t\"t\n\013lock" + "Request\0229\n\020file_credentials\030\001 \002(\0132\037.xtre" + "emfs.pbrpc.FileCredentials\022*\n\014lock_reque" + "st\030\002 \002(\0132\024.xtreemfs.pbrpc.Lock\"j\n\025xtreem" + "fs_pingMesssage\0227\n\013coordinates\030\001 \002(\0132\".x" + "treemfs.pbrpc.VivaldiCoordinates\022\030\n\020requ" + "est_response\030\002 \002(\010\"\246\001\n\036xtreemfs_rwr_auth" + "_stateRequest\0229\n\020file_credentials\030\001 \002(\0132" + "\037.xtreemfs.pbrpc.FileCredentials\022\017\n\007file" + "_id\030\002 \002(\t\0228\n\005state\030\003 \002(\0132).xtreemfs.pbrp" + "c.AuthoritativeReplicaState\"\207\001\n\"xtreemfs" + "_rwr_reset_completeRequest\0229\n\020file_crede" + "ntials\030\001 \002(\0132\037.xtreemfs.pbrpc.FileCreden" + "tials\022\017\n\007file_id\030\002 \002(\t\022\025\n\rprimary_epoch\030" + "\003 \002(\007\"q\n#xtreemfs_xloc_set_invalidateReq" + "uest\0229\n\020file_credentials\030\001 \002(\0132\037.xtreemf" + "s.pbrpc.FileCredentials\022\017\n\007file_id\030\002 \002(\t" + "\"\216\001\n$xtreemfs_xloc_set_invalidateRespons" + "e\022/\n\013lease_state\030\001 \002(\0162\032.xtreemfs.pbrpc." + "LeaseState\0225\n\016replica_status\030\002 \001(\0132\035.xtr" + "eemfs.pbrpc.ReplicaStatus*\215\001\n\017OSDHealthR" + "esult\022\034\n\030OSD_HEALTH_RESULT_PASSED\020\000\022\035\n\031O" + "SD_HEALTH_RESULT_WARNING\020\001\022\034\n\030OSD_HEALTH" + "_RESULT_FAILED\020\002\022\037\n\033OSD_HEALTH_RESULT_NO" + "T_AVAIL\020\0032\277\036\n\nOSDService\022L\n\004read\022\033.xtree" + "mfs.pbrpc.readRequest\032\032.xtreemfs.pbrpc.O" + "bjectData\"\013\215\265\030\n\000\000\000\230\265\030\001\022V\n\010truncate\022\037.xtr" + "eemfs.pbrpc.truncateRequest\032 .xtreemfs.p" + "brpc.OSDWriteResponse\"\007\215\265\030\013\000\000\000\022T\n\006unlink" + "\022\".xtreemfs.pbrpc.unlink_osd_Request\032\035.x" + "treemfs.pbrpc.emptyResponse\"\007\215\265\030\014\000\000\000\022T\n\005" + "write\022\034.xtreemfs.pbrpc.writeRequest\032 .xt" + "reemfs.pbrpc.OSDWriteResponse\"\013\215\265\030\r\000\000\000\240\265" + "\030\001\022q\n\027xtreemfs_broadcast_gmax\022..xtreemfs" + ".pbrpc.xtreemfs_broadcast_gmaxRequest\032\035." + "xtreemfs.pbrpc.emptyResponse\"\007\215\265\030\024\000\000\000\022j\n" + "\025xtreemfs_check_object\022,.xtreemfs.pbrpc." + "xtreemfs_check_objectRequest\032\032.xtreemfs." + "pbrpc.ObjectData\"\007\215\265\030\025\000\000\000\022{\n\034xtreemfs_cl" + "eanup_get_results\022\034.xtreemfs.pbrpc.empty" + "Request\0324.xtreemfs.pbrpc.xtreemfs_cleanu" + "p_get_resultsResponse\"\007\215\265\030\036\000\000\000\022y\n\033xtreem" + "fs_cleanup_is_running\022\034.xtreemfs.pbrpc.e" + "mptyRequest\0323.xtreemfs.pbrpc.xtreemfs_cl" + "eanup_is_runningResponse\"\007\215\265\030\037\000\000\000\022o\n\026xtr" + "eemfs_cleanup_start\022-.xtreemfs.pbrpc.xtr" + "eemfs_cleanup_startRequest\032\035.xtreemfs.pb" + "rpc.emptyResponse\"\007\215\265\030 \000\000\000\022q\n\027xtreemfs_c" + "leanup_status\022\034.xtreemfs.pbrpc.emptyRequ" + "est\032/.xtreemfs.pbrpc.xtreemfs_cleanup_st" + "atusResponse\"\007\215\265\030!\000\000\000\022]\n\025xtreemfs_cleanu" + "p_stop\022\034.xtreemfs.pbrpc.emptyRequest\032\035.x" + "treemfs.pbrpc.emptyResponse\"\007\215\265\030\"\000\000\000\022g\n\037" + "xtreemfs_cleanup_versions_start\022\034.xtreem" + "fs.pbrpc.emptyRequest\032\035.xtreemfs.pbrpc.e" + "mptyResponse\"\007\215\265\030#\000\000\000\022o\n\026xtreemfs_repair" + "_object\022-.xtreemfs.pbrpc.xtreemfs_repair" + "_objectRequest\032\035.xtreemfs.pbrpc.emptyRes" + "ponse\"\007\215\265\030$\000\000\000\022d\n\022xtreemfs_rwr_fetch\022).x" + "treemfs.pbrpc.xtreemfs_rwr_fetchRequest\032" + "\032.xtreemfs.pbrpc.ObjectData\"\007\215\265\030I\000\000\000\022u\n\027" + "xtreemfs_rwr_flease_msg\022..xtreemfs.pbrpc" + ".xtreemfs_rwr_flease_msgRequest\032\035.xtreem" + "fs.pbrpc.emptyResponse\"\013\215\265\030G\000\000\000\240\265\030\001\022^\n\023x" + "treemfs_rwr_notify\022\037.xtreemfs.pbrpc.File" + "Credentials\032\035.xtreemfs.pbrpc.emptyRespon" + "se\"\007\215\265\030K\000\000\000\022|\n\036xtreemfs_rwr_set_primary_" + "epoch\0225.xtreemfs.pbrpc.xtreemfs_rwr_set_" + "primary_epochRequest\032\032.xtreemfs.pbrpc.Ob" + "jectData\"\007\215\265\030N\000\000\000\022i\n\023xtreemfs_rwr_status" + "\022*.xtreemfs.pbrpc.xtreemfs_rwr_statusReq" + "uest\032\035.xtreemfs.pbrpc.ReplicaStatus\"\007\215\265\030" + "L\000\000\000\022m\n\025xtreemfs_rwr_truncate\022,.xtreemfs" + ".pbrpc.xtreemfs_rwr_truncateRequest\032\035.xt" + "reemfs.pbrpc.emptyResponse\"\007\215\265\030J\000\000\000\022m\n\023x" + "treemfs_rwr_update\022*.xtreemfs.pbrpc.xtre" + "emfs_rwr_updateRequest\032\035.xtreemfs.pbrpc." + "emptyResponse\"\013\215\265\030H\000\000\000\240\265\030\001\022q\n\027xtreemfs_r" + "wr_auth_state\022..xtreemfs.pbrpc.xtreemfs_" + "rwr_auth_stateRequest\032\035.xtreemfs.pbrpc.e" + "mptyResponse\"\007\215\265\030O\000\000\000\022y\n\033xtreemfs_rwr_re" + "set_complete\0222.xtreemfs.pbrpc.xtreemfs_r" + "wr_reset_completeRequest\032\035.xtreemfs.pbrp" + "c.emptyResponse\"\007\215\265\030P\000\000\000\022v\n\032xtreemfs_int" + "ernal_get_gmax\0221.xtreemfs.pbrpc.xtreemfs" + "_internal_get_gmaxRequest\032\034.xtreemfs.pbr" + "pc.InternalGmax\"\007\215\265\030(\000\000\000\022h\n\032xtreemfs_int" + "ernal_truncate\022\037.xtreemfs.pbrpc.truncate" + "Request\032 .xtreemfs.pbrpc.OSDWriteRespons" + "e\"\007\215\265\030)\000\000\000\022\233\001\n\037xtreemfs_internal_get_fil" + "e_size\0226.xtreemfs.pbrpc.xtreemfs_interna" + "l_get_file_sizeRequest\0327.xtreemfs.pbrpc." + "xtreemfs_internal_get_file_sizeResponse\"" + "\007\215\265\030*\000\000\000\022\207\001\n\034xtreemfs_internal_read_loca" + "l\0223.xtreemfs.pbrpc.xtreemfs_internal_rea" + "d_localRequest\032).xtreemfs.pbrpc.Internal" + "ReadLocalResponse\"\007\215\265\030+\000\000\000\022\200\001\n xtreemfs_" + "internal_get_object_set\0227.xtreemfs.pbrpc" + ".xtreemfs_internal_get_object_setRequest" + "\032\032.xtreemfs.pbrpc.ObjectList\"\007\215\265\030,\000\000\000\022\205\001" + "\n!xtreemfs_internal_get_fileid_list\022\034.xt" + "reemfs.pbrpc.emptyRequest\0329.xtreemfs.pbr" + "pc.xtreemfs_internal_get_fileid_listResp" + "onse\"\007\215\265\030-\000\000\000\022S\n\025xtreemfs_lock_acquire\022\033" + ".xtreemfs.pbrpc.lockRequest\032\024.xtreemfs.p" + "brpc.Lock\"\007\215\265\0302\000\000\000\022Q\n\023xtreemfs_lock_chec" + "k\022\033.xtreemfs.pbrpc.lockRequest\032\024.xtreemf" + "s.pbrpc.Lock\"\007\215\265\0303\000\000\000\022\\\n\025xtreemfs_lock_r" + "elease\022\033.xtreemfs.pbrpc.lockRequest\032\035.xt" + "reemfs.pbrpc.emptyResponse\"\007\215\265\0304\000\000\000\022f\n\rx" + "treemfs_ping\022%.xtreemfs.pbrpc.xtreemfs_p" + "ingMesssage\032%.xtreemfs.pbrpc.xtreemfs_pi" + "ngMesssage\"\007\215\265\030<\000\000\000\022Y\n\021xtreemfs_shutdown" + "\022\034.xtreemfs.pbrpc.emptyRequest\032\035.xtreemf" + "s.pbrpc.emptyResponse\"\007\215\265\030F\000\000\000\022\222\001\n\034xtree" + "mfs_xloc_set_invalidate\0223.xtreemfs.pbrpc" + ".xtreemfs_xloc_set_invalidateRequest\0324.x" + "treemfs.pbrpc.xtreemfs_xloc_set_invalida" + "teResponse\"\007\215\265\030Q\000\000\000\022}\n#xtreemfs_rwr_auth" + "_state_invalidated\022..xtreemfs.pbrpc.xtre" + "emfs_rwr_auth_stateRequest\032\035.xtreemfs.pb" + "rpc.emptyResponse\"\007\215\265\030R\000\000\000\032\007\225\265\0301u\000\000B(\n&o" + "rg.xtreemfs.pbrpc.generatedinterfaces", 9237); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "xtreemfs/OSD.proto", &protobuf_RegisterTypes); + InternalGmax::default_instance_ = new InternalGmax(); + Lock::default_instance_ = new Lock(); + ObjectData::default_instance_ = new ObjectData(); + ObjectList::default_instance_ = new ObjectList(); + ObjectVersion::default_instance_ = new ObjectVersion(); + TruncateRecord::default_instance_ = new TruncateRecord(); + TruncateLog::default_instance_ = new TruncateLog(); + XLocSetVersionState::default_instance_ = new XLocSetVersionState(); + ReplicaStatus::default_instance_ = new ReplicaStatus(); + ObjectVersionMapping::default_instance_ = new ObjectVersionMapping(); + AuthoritativeReplicaState::default_instance_ = new AuthoritativeReplicaState(); + InternalReadLocalResponse::default_instance_ = new InternalReadLocalResponse(); + readRequest::default_instance_ = new readRequest(); + truncateRequest::default_instance_ = new truncateRequest(); + unlink_osd_Request::default_instance_ = new unlink_osd_Request(); + writeRequest::default_instance_ = new writeRequest(); + xtreemfs_broadcast_gmaxRequest::default_instance_ = new xtreemfs_broadcast_gmaxRequest(); + xtreemfs_check_objectRequest::default_instance_ = new xtreemfs_check_objectRequest(); + xtreemfs_cleanup_get_resultsResponse::default_instance_ = new xtreemfs_cleanup_get_resultsResponse(); + xtreemfs_cleanup_is_runningResponse::default_instance_ = new xtreemfs_cleanup_is_runningResponse(); + xtreemfs_cleanup_startRequest::default_instance_ = new xtreemfs_cleanup_startRequest(); + xtreemfs_cleanup_statusResponse::default_instance_ = new xtreemfs_cleanup_statusResponse(); + xtreemfs_rwr_fetchRequest::default_instance_ = new xtreemfs_rwr_fetchRequest(); + xtreemfs_repair_objectRequest::default_instance_ = new xtreemfs_repair_objectRequest(); + xtreemfs_rwr_flease_msgRequest::default_instance_ = new xtreemfs_rwr_flease_msgRequest(); + xtreemfs_rwr_set_primary_epochRequest::default_instance_ = new xtreemfs_rwr_set_primary_epochRequest(); + xtreemfs_rwr_statusRequest::default_instance_ = new xtreemfs_rwr_statusRequest(); + xtreemfs_rwr_truncateRequest::default_instance_ = new xtreemfs_rwr_truncateRequest(); + xtreemfs_rwr_updateRequest::default_instance_ = new xtreemfs_rwr_updateRequest(); + xtreemfs_internal_get_gmaxRequest::default_instance_ = new xtreemfs_internal_get_gmaxRequest(); + xtreemfs_internal_get_file_sizeRequest::default_instance_ = new xtreemfs_internal_get_file_sizeRequest(); + xtreemfs_internal_get_file_sizeResponse::default_instance_ = new xtreemfs_internal_get_file_sizeResponse(); + xtreemfs_internal_read_localRequest::default_instance_ = new xtreemfs_internal_read_localRequest(); + xtreemfs_internal_get_object_setRequest::default_instance_ = new xtreemfs_internal_get_object_setRequest(); + xtreemfs_internal_get_fileid_listResponse::default_instance_ = new xtreemfs_internal_get_fileid_listResponse(); + lockRequest::default_instance_ = new lockRequest(); + xtreemfs_pingMesssage::default_instance_ = new xtreemfs_pingMesssage(); + xtreemfs_rwr_auth_stateRequest::default_instance_ = new xtreemfs_rwr_auth_stateRequest(); + xtreemfs_rwr_reset_completeRequest::default_instance_ = new xtreemfs_rwr_reset_completeRequest(); + xtreemfs_xloc_set_invalidateRequest::default_instance_ = new xtreemfs_xloc_set_invalidateRequest(); + xtreemfs_xloc_set_invalidateResponse::default_instance_ = new xtreemfs_xloc_set_invalidateResponse(); + InternalGmax::default_instance_->InitAsDefaultInstance(); + Lock::default_instance_->InitAsDefaultInstance(); + ObjectData::default_instance_->InitAsDefaultInstance(); + ObjectList::default_instance_->InitAsDefaultInstance(); + ObjectVersion::default_instance_->InitAsDefaultInstance(); + TruncateRecord::default_instance_->InitAsDefaultInstance(); + TruncateLog::default_instance_->InitAsDefaultInstance(); + XLocSetVersionState::default_instance_->InitAsDefaultInstance(); + ReplicaStatus::default_instance_->InitAsDefaultInstance(); + ObjectVersionMapping::default_instance_->InitAsDefaultInstance(); + AuthoritativeReplicaState::default_instance_->InitAsDefaultInstance(); + InternalReadLocalResponse::default_instance_->InitAsDefaultInstance(); + readRequest::default_instance_->InitAsDefaultInstance(); + truncateRequest::default_instance_->InitAsDefaultInstance(); + unlink_osd_Request::default_instance_->InitAsDefaultInstance(); + writeRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_broadcast_gmaxRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_check_objectRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_cleanup_get_resultsResponse::default_instance_->InitAsDefaultInstance(); + xtreemfs_cleanup_is_runningResponse::default_instance_->InitAsDefaultInstance(); + xtreemfs_cleanup_startRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_cleanup_statusResponse::default_instance_->InitAsDefaultInstance(); + xtreemfs_rwr_fetchRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_repair_objectRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_rwr_flease_msgRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_rwr_set_primary_epochRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_rwr_statusRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_rwr_truncateRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_rwr_updateRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_internal_get_gmaxRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_internal_get_file_sizeRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_internal_get_file_sizeResponse::default_instance_->InitAsDefaultInstance(); + xtreemfs_internal_read_localRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_internal_get_object_setRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_internal_get_fileid_listResponse::default_instance_->InitAsDefaultInstance(); + lockRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_pingMesssage::default_instance_->InitAsDefaultInstance(); + xtreemfs_rwr_auth_stateRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_rwr_reset_completeRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_xloc_set_invalidateRequest::default_instance_->InitAsDefaultInstance(); + xtreemfs_xloc_set_invalidateResponse::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_xtreemfs_2fOSD_2eproto { + StaticDescriptorInitializer_xtreemfs_2fOSD_2eproto() { + protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + } +} static_descriptor_initializer_xtreemfs_2fOSD_2eproto_; +const ::google::protobuf::EnumDescriptor* OSDHealthResult_descriptor() { + protobuf_AssignDescriptorsOnce(); + return OSDHealthResult_descriptor_; +} +bool OSDHealthResult_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + + +// =================================================================== + +#ifndef _MSC_VER +const int InternalGmax::kEpochFieldNumber; +const int InternalGmax::kFileSizeFieldNumber; +const int InternalGmax::kLastObjectIdFieldNumber; +#endif // !_MSC_VER + +InternalGmax::InternalGmax() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void InternalGmax::InitAsDefaultInstance() { +} + +InternalGmax::InternalGmax(const InternalGmax& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void InternalGmax::SharedCtor() { + _cached_size_ = 0; + epoch_ = GOOGLE_ULONGLONG(0); + file_size_ = GOOGLE_ULONGLONG(0); + last_object_id_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +InternalGmax::~InternalGmax() { + SharedDtor(); +} + +void InternalGmax::SharedDtor() { + if (this != default_instance_) { + } +} + +void InternalGmax::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InternalGmax::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InternalGmax_descriptor_; +} + +const InternalGmax& InternalGmax::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +InternalGmax* InternalGmax::default_instance_ = NULL; + +InternalGmax* InternalGmax::New() const { + return new InternalGmax; +} + +void InternalGmax::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + epoch_ = GOOGLE_ULONGLONG(0); + file_size_ = GOOGLE_ULONGLONG(0); + last_object_id_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool InternalGmax::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 epoch = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &epoch_))); + set_has_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_file_size; + break; + } + + // required fixed64 file_size = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_file_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &file_size_))); + set_has_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_last_object_id; + break; + } + + // required fixed64 last_object_id = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_last_object_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &last_object_id_))); + set_has_last_object_id(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void InternalGmax::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 epoch = 1; + if (has_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->epoch(), output); + } + + // required fixed64 file_size = 2; + if (has_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->file_size(), output); + } + + // required fixed64 last_object_id = 3; + if (has_last_object_id()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->last_object_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* InternalGmax::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 epoch = 1; + if (has_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->epoch(), target); + } + + // required fixed64 file_size = 2; + if (has_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->file_size(), target); + } + + // required fixed64 last_object_id = 3; + if (has_last_object_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->last_object_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int InternalGmax::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 epoch = 1; + if (has_epoch()) { + total_size += 1 + 8; + } + + // required fixed64 file_size = 2; + if (has_file_size()) { + total_size += 1 + 8; + } + + // required fixed64 last_object_id = 3; + if (has_last_object_id()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void InternalGmax::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const InternalGmax* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void InternalGmax::MergeFrom(const InternalGmax& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_epoch()) { + set_epoch(from.epoch()); + } + if (from.has_file_size()) { + set_file_size(from.file_size()); + } + if (from.has_last_object_id()) { + set_last_object_id(from.last_object_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void InternalGmax::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InternalGmax::CopyFrom(const InternalGmax& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InternalGmax::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void InternalGmax::Swap(InternalGmax* other) { + if (other != this) { + std::swap(epoch_, other->epoch_); + std::swap(file_size_, other->file_size_); + std::swap(last_object_id_, other->last_object_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata InternalGmax::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InternalGmax_descriptor_; + metadata.reflection = InternalGmax_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int Lock::kClientPidFieldNumber; +const int Lock::kClientUuidFieldNumber; +const int Lock::kLengthFieldNumber; +const int Lock::kOffsetFieldNumber; +const int Lock::kExclusiveFieldNumber; +#endif // !_MSC_VER + +Lock::Lock() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Lock::InitAsDefaultInstance() { +} + +Lock::Lock(const Lock& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Lock::SharedCtor() { + _cached_size_ = 0; + client_pid_ = 0u; + client_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + length_ = GOOGLE_ULONGLONG(0); + offset_ = GOOGLE_ULONGLONG(0); + exclusive_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Lock::~Lock() { + SharedDtor(); +} + +void Lock::SharedDtor() { + if (client_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete client_uuid_; + } + if (this != default_instance_) { + } +} + +void Lock::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Lock::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Lock_descriptor_; +} + +const Lock& Lock::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +Lock* Lock::default_instance_ = NULL; + +Lock* Lock::New() const { + return new Lock; +} + +void Lock::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + client_pid_ = 0u; + if (has_client_uuid()) { + if (client_uuid_ != &::google::protobuf::internal::kEmptyString) { + client_uuid_->clear(); + } + } + length_ = GOOGLE_ULONGLONG(0); + offset_ = GOOGLE_ULONGLONG(0); + exclusive_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Lock::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 client_pid = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &client_pid_))); + set_has_client_pid(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_client_uuid; + break; + } + + // required string client_uuid = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_client_uuid: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_client_uuid())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->client_uuid().data(), this->client_uuid().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_length; + break; + } + + // required fixed64 length = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &length_))); + set_has_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_offset; + break; + } + + // required fixed64 offset = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &offset_))); + set_has_offset(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(40)) goto parse_exclusive; + break; + } + + // required bool exclusive = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_exclusive: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &exclusive_))); + set_has_exclusive(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Lock::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 client_pid = 1; + if (has_client_pid()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->client_pid(), output); + } + + // required string client_uuid = 2; + if (has_client_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->client_uuid().data(), this->client_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->client_uuid(), output); + } + + // required fixed64 length = 3; + if (has_length()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->length(), output); + } + + // required fixed64 offset = 4; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->offset(), output); + } + + // required bool exclusive = 5; + if (has_exclusive()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->exclusive(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Lock::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 client_pid = 1; + if (has_client_pid()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->client_pid(), target); + } + + // required string client_uuid = 2; + if (has_client_uuid()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->client_uuid().data(), this->client_uuid().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->client_uuid(), target); + } + + // required fixed64 length = 3; + if (has_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->length(), target); + } + + // required fixed64 offset = 4; + if (has_offset()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->offset(), target); + } + + // required bool exclusive = 5; + if (has_exclusive()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->exclusive(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Lock::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 client_pid = 1; + if (has_client_pid()) { + total_size += 1 + 4; + } + + // required string client_uuid = 2; + if (has_client_uuid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->client_uuid()); + } + + // required fixed64 length = 3; + if (has_length()) { + total_size += 1 + 8; + } + + // required fixed64 offset = 4; + if (has_offset()) { + total_size += 1 + 8; + } + + // required bool exclusive = 5; + if (has_exclusive()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Lock::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Lock* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Lock::MergeFrom(const Lock& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_client_pid()) { + set_client_pid(from.client_pid()); + } + if (from.has_client_uuid()) { + set_client_uuid(from.client_uuid()); + } + if (from.has_length()) { + set_length(from.length()); + } + if (from.has_offset()) { + set_offset(from.offset()); + } + if (from.has_exclusive()) { + set_exclusive(from.exclusive()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Lock::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Lock::CopyFrom(const Lock& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Lock::IsInitialized() const { + if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false; + + return true; +} + +void Lock::Swap(Lock* other) { + if (other != this) { + std::swap(client_pid_, other->client_pid_); + std::swap(client_uuid_, other->client_uuid_); + std::swap(length_, other->length_); + std::swap(offset_, other->offset_); + std::swap(exclusive_, other->exclusive_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Lock::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Lock_descriptor_; + metadata.reflection = Lock_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ObjectData::kChecksumFieldNumber; +const int ObjectData::kInvalidChecksumOnOsdFieldNumber; +const int ObjectData::kZeroPaddingFieldNumber; +#endif // !_MSC_VER + +ObjectData::ObjectData() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ObjectData::InitAsDefaultInstance() { +} + +ObjectData::ObjectData(const ObjectData& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ObjectData::SharedCtor() { + _cached_size_ = 0; + checksum_ = 0u; + invalid_checksum_on_osd_ = false; + zero_padding_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ObjectData::~ObjectData() { + SharedDtor(); +} + +void ObjectData::SharedDtor() { + if (this != default_instance_) { + } +} + +void ObjectData::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ObjectData::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ObjectData_descriptor_; +} + +const ObjectData& ObjectData::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +ObjectData* ObjectData::default_instance_ = NULL; + +ObjectData* ObjectData::New() const { + return new ObjectData; +} + +void ObjectData::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + checksum_ = 0u; + invalid_checksum_on_osd_ = false; + zero_padding_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ObjectData::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 checksum = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &checksum_))); + set_has_checksum(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_invalid_checksum_on_osd; + break; + } + + // required bool invalid_checksum_on_osd = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_invalid_checksum_on_osd: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &invalid_checksum_on_osd_))); + set_has_invalid_checksum_on_osd(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_zero_padding; + break; + } + + // required fixed32 zero_padding = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_zero_padding: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &zero_padding_))); + set_has_zero_padding(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ObjectData::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 checksum = 1; + if (has_checksum()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->checksum(), output); + } + + // required bool invalid_checksum_on_osd = 2; + if (has_invalid_checksum_on_osd()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->invalid_checksum_on_osd(), output); + } + + // required fixed32 zero_padding = 3; + if (has_zero_padding()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->zero_padding(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ObjectData::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 checksum = 1; + if (has_checksum()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->checksum(), target); + } + + // required bool invalid_checksum_on_osd = 2; + if (has_invalid_checksum_on_osd()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->invalid_checksum_on_osd(), target); + } + + // required fixed32 zero_padding = 3; + if (has_zero_padding()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->zero_padding(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ObjectData::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 checksum = 1; + if (has_checksum()) { + total_size += 1 + 4; + } + + // required bool invalid_checksum_on_osd = 2; + if (has_invalid_checksum_on_osd()) { + total_size += 1 + 1; + } + + // required fixed32 zero_padding = 3; + if (has_zero_padding()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ObjectData::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ObjectData* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ObjectData::MergeFrom(const ObjectData& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_checksum()) { + set_checksum(from.checksum()); + } + if (from.has_invalid_checksum_on_osd()) { + set_invalid_checksum_on_osd(from.invalid_checksum_on_osd()); + } + if (from.has_zero_padding()) { + set_zero_padding(from.zero_padding()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ObjectData::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ObjectData::CopyFrom(const ObjectData& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ObjectData::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void ObjectData::Swap(ObjectData* other) { + if (other != this) { + std::swap(checksum_, other->checksum_); + std::swap(invalid_checksum_on_osd_, other->invalid_checksum_on_osd_); + std::swap(zero_padding_, other->zero_padding_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ObjectData::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ObjectData_descriptor_; + metadata.reflection = ObjectData_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ObjectList::kSetFieldNumber; +const int ObjectList::kStripeWidthFieldNumber; +const int ObjectList::kFirstFieldNumber; +#endif // !_MSC_VER + +ObjectList::ObjectList() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ObjectList::InitAsDefaultInstance() { +} + +ObjectList::ObjectList(const ObjectList& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ObjectList::SharedCtor() { + _cached_size_ = 0; + set_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + stripe_width_ = 0u; + first__ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ObjectList::~ObjectList() { + SharedDtor(); +} + +void ObjectList::SharedDtor() { + if (set_ != &::google::protobuf::internal::kEmptyString) { + delete set_; + } + if (this != default_instance_) { + } +} + +void ObjectList::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ObjectList::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ObjectList_descriptor_; +} + +const ObjectList& ObjectList::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +ObjectList* ObjectList::default_instance_ = NULL; + +ObjectList* ObjectList::New() const { + return new ObjectList; +} + +void ObjectList::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_set()) { + if (set_ != &::google::protobuf::internal::kEmptyString) { + set_->clear(); + } + } + stripe_width_ = 0u; + first__ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ObjectList::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required bytes set = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_set())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_stripe_width; + break; + } + + // required fixed32 stripe_width = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_stripe_width: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &stripe_width_))); + set_has_stripe_width(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_first_; + break; + } + + // required fixed32 first_ = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_first_: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &first__))); + set_has_first_(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ObjectList::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required bytes set = 1; + if (has_set()) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 1, this->set(), output); + } + + // required fixed32 stripe_width = 2; + if (has_stripe_width()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->stripe_width(), output); + } + + // required fixed32 first_ = 3; + if (has_first_()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->first_(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ObjectList::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required bytes set = 1; + if (has_set()) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 1, this->set(), target); + } + + // required fixed32 stripe_width = 2; + if (has_stripe_width()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->stripe_width(), target); + } + + // required fixed32 first_ = 3; + if (has_first_()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->first_(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ObjectList::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required bytes set = 1; + if (has_set()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->set()); + } + + // required fixed32 stripe_width = 2; + if (has_stripe_width()) { + total_size += 1 + 4; + } + + // required fixed32 first_ = 3; + if (has_first_()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ObjectList::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ObjectList* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ObjectList::MergeFrom(const ObjectList& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_set()) { + set_set(from.set()); + } + if (from.has_stripe_width()) { + set_stripe_width(from.stripe_width()); + } + if (from.has_first_()) { + set_first_(from.first_()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ObjectList::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ObjectList::CopyFrom(const ObjectList& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ObjectList::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void ObjectList::Swap(ObjectList* other) { + if (other != this) { + std::swap(set_, other->set_); + std::swap(stripe_width_, other->stripe_width_); + std::swap(first__, other->first__); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ObjectList::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ObjectList_descriptor_; + metadata.reflection = ObjectList_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ObjectVersion::kObjectNumberFieldNumber; +const int ObjectVersion::kObjectVersionFieldNumber; +#endif // !_MSC_VER + +ObjectVersion::ObjectVersion() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ObjectVersion::InitAsDefaultInstance() { +} + +ObjectVersion::ObjectVersion(const ObjectVersion& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ObjectVersion::SharedCtor() { + _cached_size_ = 0; + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ObjectVersion::~ObjectVersion() { + SharedDtor(); +} + +void ObjectVersion::SharedDtor() { + if (this != default_instance_) { + } +} + +void ObjectVersion::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ObjectVersion::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ObjectVersion_descriptor_; +} + +const ObjectVersion& ObjectVersion::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +ObjectVersion* ObjectVersion::default_instance_ = NULL; + +ObjectVersion* ObjectVersion::New() const { + return new ObjectVersion; +} + +void ObjectVersion::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ObjectVersion::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 object_number = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ObjectVersion::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 object_number = 1; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->object_number(), output); + } + + // required fixed64 object_version = 2; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->object_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ObjectVersion::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 object_number = 1; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->object_number(), target); + } + + // required fixed64 object_version = 2; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->object_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ObjectVersion::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 object_number = 1; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 2; + if (has_object_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ObjectVersion::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ObjectVersion* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ObjectVersion::MergeFrom(const ObjectVersion& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ObjectVersion::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ObjectVersion::CopyFrom(const ObjectVersion& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ObjectVersion::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void ObjectVersion::Swap(ObjectVersion* other) { + if (other != this) { + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ObjectVersion::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ObjectVersion_descriptor_; + metadata.reflection = ObjectVersion_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int TruncateRecord::kVersionFieldNumber; +const int TruncateRecord::kLastObjectNumberFieldNumber; +#endif // !_MSC_VER + +TruncateRecord::TruncateRecord() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void TruncateRecord::InitAsDefaultInstance() { +} + +TruncateRecord::TruncateRecord(const TruncateRecord& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void TruncateRecord::SharedCtor() { + _cached_size_ = 0; + version_ = GOOGLE_ULONGLONG(0); + last_object_number_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +TruncateRecord::~TruncateRecord() { + SharedDtor(); +} + +void TruncateRecord::SharedDtor() { + if (this != default_instance_) { + } +} + +void TruncateRecord::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TruncateRecord::descriptor() { + protobuf_AssignDescriptorsOnce(); + return TruncateRecord_descriptor_; +} + +const TruncateRecord& TruncateRecord::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +TruncateRecord* TruncateRecord::default_instance_ = NULL; + +TruncateRecord* TruncateRecord::New() const { + return new TruncateRecord; +} + +void TruncateRecord::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + version_ = GOOGLE_ULONGLONG(0); + last_object_number_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool TruncateRecord::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 version = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &version_))); + set_has_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_last_object_number; + break; + } + + // required fixed64 last_object_number = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_last_object_number: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &last_object_number_))); + set_has_last_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void TruncateRecord::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 version = 1; + if (has_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->version(), output); + } + + // required fixed64 last_object_number = 2; + if (has_last_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->last_object_number(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* TruncateRecord::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 version = 1; + if (has_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->version(), target); + } + + // required fixed64 last_object_number = 2; + if (has_last_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->last_object_number(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int TruncateRecord::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 version = 1; + if (has_version()) { + total_size += 1 + 8; + } + + // required fixed64 last_object_number = 2; + if (has_last_object_number()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TruncateRecord::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const TruncateRecord* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void TruncateRecord::MergeFrom(const TruncateRecord& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_version()) { + set_version(from.version()); + } + if (from.has_last_object_number()) { + set_last_object_number(from.last_object_number()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void TruncateRecord::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TruncateRecord::CopyFrom(const TruncateRecord& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TruncateRecord::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void TruncateRecord::Swap(TruncateRecord* other) { + if (other != this) { + std::swap(version_, other->version_); + std::swap(last_object_number_, other->last_object_number_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata TruncateRecord::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = TruncateRecord_descriptor_; + metadata.reflection = TruncateRecord_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int TruncateLog::kRecordsFieldNumber; +#endif // !_MSC_VER + +TruncateLog::TruncateLog() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void TruncateLog::InitAsDefaultInstance() { +} + +TruncateLog::TruncateLog(const TruncateLog& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void TruncateLog::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +TruncateLog::~TruncateLog() { + SharedDtor(); +} + +void TruncateLog::SharedDtor() { + if (this != default_instance_) { + } +} + +void TruncateLog::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TruncateLog::descriptor() { + protobuf_AssignDescriptorsOnce(); + return TruncateLog_descriptor_; +} + +const TruncateLog& TruncateLog::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +TruncateLog* TruncateLog::default_instance_ = NULL; + +TruncateLog* TruncateLog::New() const { + return new TruncateLog; +} + +void TruncateLog::Clear() { + records_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool TruncateLog::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .xtreemfs.pbrpc.TruncateRecord records = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_records: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_records())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_records; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void TruncateLog::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .xtreemfs.pbrpc.TruncateRecord records = 1; + for (int i = 0; i < this->records_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->records(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* TruncateLog::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .xtreemfs.pbrpc.TruncateRecord records = 1; + for (int i = 0; i < this->records_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->records(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int TruncateLog::ByteSize() const { + int total_size = 0; + + // repeated .xtreemfs.pbrpc.TruncateRecord records = 1; + total_size += 1 * this->records_size(); + for (int i = 0; i < this->records_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->records(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TruncateLog::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const TruncateLog* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void TruncateLog::MergeFrom(const TruncateLog& from) { + GOOGLE_CHECK_NE(&from, this); + records_.MergeFrom(from.records_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void TruncateLog::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TruncateLog::CopyFrom(const TruncateLog& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TruncateLog::IsInitialized() const { + + for (int i = 0; i < records_size(); i++) { + if (!this->records(i).IsInitialized()) return false; + } + return true; +} + +void TruncateLog::Swap(TruncateLog* other) { + if (other != this) { + records_.Swap(&other->records_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata TruncateLog::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = TruncateLog_descriptor_; + metadata.reflection = TruncateLog_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int XLocSetVersionState::kVersionFieldNumber; +const int XLocSetVersionState::kInvalidatedFieldNumber; +const int XLocSetVersionState::kModifiedTimeFieldNumber; +#endif // !_MSC_VER + +XLocSetVersionState::XLocSetVersionState() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void XLocSetVersionState::InitAsDefaultInstance() { +} + +XLocSetVersionState::XLocSetVersionState(const XLocSetVersionState& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void XLocSetVersionState::SharedCtor() { + _cached_size_ = 0; + version_ = 0u; + invalidated_ = false; + modified_time_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +XLocSetVersionState::~XLocSetVersionState() { + SharedDtor(); +} + +void XLocSetVersionState::SharedDtor() { + if (this != default_instance_) { + } +} + +void XLocSetVersionState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* XLocSetVersionState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return XLocSetVersionState_descriptor_; +} + +const XLocSetVersionState& XLocSetVersionState::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +XLocSetVersionState* XLocSetVersionState::default_instance_ = NULL; + +XLocSetVersionState* XLocSetVersionState::New() const { + return new XLocSetVersionState; +} + +void XLocSetVersionState::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + version_ = 0u; + invalidated_ = false; + modified_time_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool XLocSetVersionState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed32 version = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &version_))); + set_has_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_invalidated; + break; + } + + // required bool invalidated = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_invalidated: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &invalidated_))); + set_has_invalidated(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_modified_time; + break; + } + + // optional fixed64 modified_time = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_modified_time: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &modified_time_))); + set_has_modified_time(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void XLocSetVersionState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed32 version = 1; + if (has_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->version(), output); + } + + // required bool invalidated = 2; + if (has_invalidated()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->invalidated(), output); + } + + // optional fixed64 modified_time = 3; + if (has_modified_time()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->modified_time(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* XLocSetVersionState::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed32 version = 1; + if (has_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->version(), target); + } + + // required bool invalidated = 2; + if (has_invalidated()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->invalidated(), target); + } + + // optional fixed64 modified_time = 3; + if (has_modified_time()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->modified_time(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int XLocSetVersionState::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed32 version = 1; + if (has_version()) { + total_size += 1 + 4; + } + + // required bool invalidated = 2; + if (has_invalidated()) { + total_size += 1 + 1; + } + + // optional fixed64 modified_time = 3; + if (has_modified_time()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void XLocSetVersionState::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const XLocSetVersionState* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void XLocSetVersionState::MergeFrom(const XLocSetVersionState& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_version()) { + set_version(from.version()); + } + if (from.has_invalidated()) { + set_invalidated(from.invalidated()); + } + if (from.has_modified_time()) { + set_modified_time(from.modified_time()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void XLocSetVersionState::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void XLocSetVersionState::CopyFrom(const XLocSetVersionState& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool XLocSetVersionState::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void XLocSetVersionState::Swap(XLocSetVersionState* other) { + if (other != this) { + std::swap(version_, other->version_); + std::swap(invalidated_, other->invalidated_); + std::swap(modified_time_, other->modified_time_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata XLocSetVersionState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = XLocSetVersionState_descriptor_; + metadata.reflection = XLocSetVersionState_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ReplicaStatus::kTruncateEpochFieldNumber; +const int ReplicaStatus::kFileSizeFieldNumber; +const int ReplicaStatus::kMaxObjVersionFieldNumber; +const int ReplicaStatus::kPrimaryEpochFieldNumber; +const int ReplicaStatus::kObjectVersionsFieldNumber; +const int ReplicaStatus::kTruncateLogFieldNumber; +#endif // !_MSC_VER + +ReplicaStatus::ReplicaStatus() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ReplicaStatus::InitAsDefaultInstance() { + truncate_log_ = const_cast< ::xtreemfs::pbrpc::TruncateLog*>(&::xtreemfs::pbrpc::TruncateLog::default_instance()); +} + +ReplicaStatus::ReplicaStatus(const ReplicaStatus& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ReplicaStatus::SharedCtor() { + _cached_size_ = 0; + truncate_epoch_ = GOOGLE_ULONGLONG(0); + file_size_ = GOOGLE_ULONGLONG(0); + max_obj_version_ = GOOGLE_ULONGLONG(0); + primary_epoch_ = 0u; + truncate_log_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ReplicaStatus::~ReplicaStatus() { + SharedDtor(); +} + +void ReplicaStatus::SharedDtor() { + if (this != default_instance_) { + delete truncate_log_; + } +} + +void ReplicaStatus::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ReplicaStatus::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ReplicaStatus_descriptor_; +} + +const ReplicaStatus& ReplicaStatus::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +ReplicaStatus* ReplicaStatus::default_instance_ = NULL; + +ReplicaStatus* ReplicaStatus::New() const { + return new ReplicaStatus; +} + +void ReplicaStatus::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + truncate_epoch_ = GOOGLE_ULONGLONG(0); + file_size_ = GOOGLE_ULONGLONG(0); + max_obj_version_ = GOOGLE_ULONGLONG(0); + primary_epoch_ = 0u; + if (has_truncate_log()) { + if (truncate_log_ != NULL) truncate_log_->::xtreemfs::pbrpc::TruncateLog::Clear(); + } + } + objectversions_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ReplicaStatus::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 truncate_epoch = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &truncate_epoch_))); + set_has_truncate_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_file_size; + break; + } + + // required fixed64 file_size = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_file_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &file_size_))); + set_has_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_max_obj_version; + break; + } + + // required fixed64 max_obj_version = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_max_obj_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &max_obj_version_))); + set_has_max_obj_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(37)) goto parse_primary_epoch; + break; + } + + // required fixed32 primary_epoch = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_primary_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &primary_epoch_))); + set_has_primary_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_objectVersions; + break; + } + + // repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_objectVersions: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_objectversions())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_objectVersions; + if (input->ExpectTag(50)) goto parse_truncate_log; + break; + } + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_truncate_log: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_truncate_log())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ReplicaStatus::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 truncate_epoch = 1; + if (has_truncate_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->truncate_epoch(), output); + } + + // required fixed64 file_size = 2; + if (has_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->file_size(), output); + } + + // required fixed64 max_obj_version = 3; + if (has_max_obj_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->max_obj_version(), output); + } + + // required fixed32 primary_epoch = 4; + if (has_primary_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->primary_epoch(), output); + } + + // repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5; + for (int i = 0; i < this->objectversions_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->objectversions(i), output); + } + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 6; + if (has_truncate_log()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->truncate_log(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ReplicaStatus::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 truncate_epoch = 1; + if (has_truncate_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->truncate_epoch(), target); + } + + // required fixed64 file_size = 2; + if (has_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->file_size(), target); + } + + // required fixed64 max_obj_version = 3; + if (has_max_obj_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->max_obj_version(), target); + } + + // required fixed32 primary_epoch = 4; + if (has_primary_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->primary_epoch(), target); + } + + // repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5; + for (int i = 0; i < this->objectversions_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->objectversions(i), target); + } + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 6; + if (has_truncate_log()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->truncate_log(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ReplicaStatus::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 truncate_epoch = 1; + if (has_truncate_epoch()) { + total_size += 1 + 8; + } + + // required fixed64 file_size = 2; + if (has_file_size()) { + total_size += 1 + 8; + } + + // required fixed64 max_obj_version = 3; + if (has_max_obj_version()) { + total_size += 1 + 8; + } + + // required fixed32 primary_epoch = 4; + if (has_primary_epoch()) { + total_size += 1 + 4; + } + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 6; + if (has_truncate_log()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->truncate_log()); + } + + } + // repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5; + total_size += 1 * this->objectversions_size(); + for (int i = 0; i < this->objectversions_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->objectversions(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ReplicaStatus::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ReplicaStatus* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ReplicaStatus::MergeFrom(const ReplicaStatus& from) { + GOOGLE_CHECK_NE(&from, this); + objectversions_.MergeFrom(from.objectversions_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_truncate_epoch()) { + set_truncate_epoch(from.truncate_epoch()); + } + if (from.has_file_size()) { + set_file_size(from.file_size()); + } + if (from.has_max_obj_version()) { + set_max_obj_version(from.max_obj_version()); + } + if (from.has_primary_epoch()) { + set_primary_epoch(from.primary_epoch()); + } + if (from.has_truncate_log()) { + mutable_truncate_log()->::xtreemfs::pbrpc::TruncateLog::MergeFrom(from.truncate_log()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ReplicaStatus::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReplicaStatus::CopyFrom(const ReplicaStatus& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReplicaStatus::IsInitialized() const { + if ((_has_bits_[0] & 0x0000002f) != 0x0000002f) return false; + + for (int i = 0; i < objectversions_size(); i++) { + if (!this->objectversions(i).IsInitialized()) return false; + } + if (has_truncate_log()) { + if (!this->truncate_log().IsInitialized()) return false; + } + return true; +} + +void ReplicaStatus::Swap(ReplicaStatus* other) { + if (other != this) { + std::swap(truncate_epoch_, other->truncate_epoch_); + std::swap(file_size_, other->file_size_); + std::swap(max_obj_version_, other->max_obj_version_); + std::swap(primary_epoch_, other->primary_epoch_); + objectversions_.Swap(&other->objectversions_); + std::swap(truncate_log_, other->truncate_log_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ReplicaStatus::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ReplicaStatus_descriptor_; + metadata.reflection = ReplicaStatus_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ObjectVersionMapping::kObjectNumberFieldNumber; +const int ObjectVersionMapping::kObjectVersionFieldNumber; +const int ObjectVersionMapping::kOsdUuidsFieldNumber; +#endif // !_MSC_VER + +ObjectVersionMapping::ObjectVersionMapping() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ObjectVersionMapping::InitAsDefaultInstance() { +} + +ObjectVersionMapping::ObjectVersionMapping(const ObjectVersionMapping& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ObjectVersionMapping::SharedCtor() { + _cached_size_ = 0; + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ObjectVersionMapping::~ObjectVersionMapping() { + SharedDtor(); +} + +void ObjectVersionMapping::SharedDtor() { + if (this != default_instance_) { + } +} + +void ObjectVersionMapping::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ObjectVersionMapping::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ObjectVersionMapping_descriptor_; +} + +const ObjectVersionMapping& ObjectVersionMapping::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +ObjectVersionMapping* ObjectVersionMapping::default_instance_ = NULL; + +ObjectVersionMapping* ObjectVersionMapping::New() const { + return new ObjectVersionMapping; +} + +void ObjectVersionMapping::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + } + osd_uuids_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ObjectVersionMapping::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 object_number = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_osd_uuids; + break; + } + + // repeated string osd_uuids = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_osd_uuids: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_osd_uuids())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(this->osd_uuids_size() - 1).data(), + this->osd_uuids(this->osd_uuids_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_osd_uuids; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ObjectVersionMapping::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 object_number = 1; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->object_number(), output); + } + + // required fixed64 object_version = 2; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->object_version(), output); + } + + // repeated string osd_uuids = 3; + for (int i = 0; i < this->osd_uuids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(i).data(), this->osd_uuids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->osd_uuids(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ObjectVersionMapping::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 object_number = 1; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->object_number(), target); + } + + // required fixed64 object_version = 2; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->object_version(), target); + } + + // repeated string osd_uuids = 3; + for (int i = 0; i < this->osd_uuids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->osd_uuids(i).data(), this->osd_uuids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(3, this->osd_uuids(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ObjectVersionMapping::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 object_number = 1; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 2; + if (has_object_version()) { + total_size += 1 + 8; + } + + } + // repeated string osd_uuids = 3; + total_size += 1 * this->osd_uuids_size(); + for (int i = 0; i < this->osd_uuids_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->osd_uuids(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ObjectVersionMapping::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ObjectVersionMapping* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ObjectVersionMapping::MergeFrom(const ObjectVersionMapping& from) { + GOOGLE_CHECK_NE(&from, this); + osd_uuids_.MergeFrom(from.osd_uuids_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ObjectVersionMapping::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ObjectVersionMapping::CopyFrom(const ObjectVersionMapping& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ObjectVersionMapping::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void ObjectVersionMapping::Swap(ObjectVersionMapping* other) { + if (other != this) { + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + osd_uuids_.Swap(&other->osd_uuids_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ObjectVersionMapping::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ObjectVersionMapping_descriptor_; + metadata.reflection = ObjectVersionMapping_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AuthoritativeReplicaState::kTruncateEpochFieldNumber; +const int AuthoritativeReplicaState::kMaxObjVersionFieldNumber; +const int AuthoritativeReplicaState::kObjectVersionsFieldNumber; +const int AuthoritativeReplicaState::kTruncateLogFieldNumber; +#endif // !_MSC_VER + +AuthoritativeReplicaState::AuthoritativeReplicaState() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void AuthoritativeReplicaState::InitAsDefaultInstance() { + truncate_log_ = const_cast< ::xtreemfs::pbrpc::TruncateLog*>(&::xtreemfs::pbrpc::TruncateLog::default_instance()); +} + +AuthoritativeReplicaState::AuthoritativeReplicaState(const AuthoritativeReplicaState& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void AuthoritativeReplicaState::SharedCtor() { + _cached_size_ = 0; + truncate_epoch_ = GOOGLE_ULONGLONG(0); + max_obj_version_ = GOOGLE_ULONGLONG(0); + truncate_log_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AuthoritativeReplicaState::~AuthoritativeReplicaState() { + SharedDtor(); +} + +void AuthoritativeReplicaState::SharedDtor() { + if (this != default_instance_) { + delete truncate_log_; + } +} + +void AuthoritativeReplicaState::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AuthoritativeReplicaState::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AuthoritativeReplicaState_descriptor_; +} + +const AuthoritativeReplicaState& AuthoritativeReplicaState::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +AuthoritativeReplicaState* AuthoritativeReplicaState::default_instance_ = NULL; + +AuthoritativeReplicaState* AuthoritativeReplicaState::New() const { + return new AuthoritativeReplicaState; +} + +void AuthoritativeReplicaState::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + truncate_epoch_ = GOOGLE_ULONGLONG(0); + max_obj_version_ = GOOGLE_ULONGLONG(0); + if (has_truncate_log()) { + if (truncate_log_ != NULL) truncate_log_->::xtreemfs::pbrpc::TruncateLog::Clear(); + } + } + objectversions_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AuthoritativeReplicaState::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 truncate_epoch = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &truncate_epoch_))); + set_has_truncate_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_objectVersions; + break; + } + + // repeated .xtreemfs.pbrpc.ObjectVersionMapping objectVersions = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_objectVersions: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_objectversions())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_objectVersions; + if (input->ExpectTag(26)) goto parse_truncate_log; + break; + } + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_truncate_log: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_truncate_log())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_max_obj_version; + break; + } + + // required fixed64 max_obj_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_max_obj_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &max_obj_version_))); + set_has_max_obj_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void AuthoritativeReplicaState::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 truncate_epoch = 1; + if (has_truncate_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->truncate_epoch(), output); + } + + // repeated .xtreemfs.pbrpc.ObjectVersionMapping objectVersions = 2; + for (int i = 0; i < this->objectversions_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->objectversions(i), output); + } + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 3; + if (has_truncate_log()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->truncate_log(), output); + } + + // required fixed64 max_obj_version = 4; + if (has_max_obj_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->max_obj_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* AuthoritativeReplicaState::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 truncate_epoch = 1; + if (has_truncate_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->truncate_epoch(), target); + } + + // repeated .xtreemfs.pbrpc.ObjectVersionMapping objectVersions = 2; + for (int i = 0; i < this->objectversions_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->objectversions(i), target); + } + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 3; + if (has_truncate_log()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->truncate_log(), target); + } + + // required fixed64 max_obj_version = 4; + if (has_max_obj_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->max_obj_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int AuthoritativeReplicaState::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 truncate_epoch = 1; + if (has_truncate_epoch()) { + total_size += 1 + 8; + } + + // required fixed64 max_obj_version = 4; + if (has_max_obj_version()) { + total_size += 1 + 8; + } + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 3; + if (has_truncate_log()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->truncate_log()); + } + + } + // repeated .xtreemfs.pbrpc.ObjectVersionMapping objectVersions = 2; + total_size += 1 * this->objectversions_size(); + for (int i = 0; i < this->objectversions_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->objectversions(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AuthoritativeReplicaState::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AuthoritativeReplicaState* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AuthoritativeReplicaState::MergeFrom(const AuthoritativeReplicaState& from) { + GOOGLE_CHECK_NE(&from, this); + objectversions_.MergeFrom(from.objectversions_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_truncate_epoch()) { + set_truncate_epoch(from.truncate_epoch()); + } + if (from.has_max_obj_version()) { + set_max_obj_version(from.max_obj_version()); + } + if (from.has_truncate_log()) { + mutable_truncate_log()->::xtreemfs::pbrpc::TruncateLog::MergeFrom(from.truncate_log()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AuthoritativeReplicaState::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AuthoritativeReplicaState::CopyFrom(const AuthoritativeReplicaState& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AuthoritativeReplicaState::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false; + + for (int i = 0; i < objectversions_size(); i++) { + if (!this->objectversions(i).IsInitialized()) return false; + } + if (has_truncate_log()) { + if (!this->truncate_log().IsInitialized()) return false; + } + return true; +} + +void AuthoritativeReplicaState::Swap(AuthoritativeReplicaState* other) { + if (other != this) { + std::swap(truncate_epoch_, other->truncate_epoch_); + std::swap(max_obj_version_, other->max_obj_version_); + objectversions_.Swap(&other->objectversions_); + std::swap(truncate_log_, other->truncate_log_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata AuthoritativeReplicaState::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AuthoritativeReplicaState_descriptor_; + metadata.reflection = AuthoritativeReplicaState_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int InternalReadLocalResponse::kDataFieldNumber; +const int InternalReadLocalResponse::kObjectSetFieldNumber; +#endif // !_MSC_VER + +InternalReadLocalResponse::InternalReadLocalResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void InternalReadLocalResponse::InitAsDefaultInstance() { + data_ = const_cast< ::xtreemfs::pbrpc::ObjectData*>(&::xtreemfs::pbrpc::ObjectData::default_instance()); +} + +InternalReadLocalResponse::InternalReadLocalResponse(const InternalReadLocalResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void InternalReadLocalResponse::SharedCtor() { + _cached_size_ = 0; + data_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +InternalReadLocalResponse::~InternalReadLocalResponse() { + SharedDtor(); +} + +void InternalReadLocalResponse::SharedDtor() { + if (this != default_instance_) { + delete data_; + } +} + +void InternalReadLocalResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* InternalReadLocalResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return InternalReadLocalResponse_descriptor_; +} + +const InternalReadLocalResponse& InternalReadLocalResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +InternalReadLocalResponse* InternalReadLocalResponse::default_instance_ = NULL; + +InternalReadLocalResponse* InternalReadLocalResponse::New() const { + return new InternalReadLocalResponse; +} + +void InternalReadLocalResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_data()) { + if (data_ != NULL) data_->::xtreemfs::pbrpc::ObjectData::Clear(); + } + } + object_set_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool InternalReadLocalResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.ObjectData data = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_data())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_object_set; + break; + } + + // repeated .xtreemfs.pbrpc.ObjectList object_set = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_object_set: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_object_set())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_object_set; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void InternalReadLocalResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.ObjectData data = 1; + if (has_data()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->data(), output); + } + + // repeated .xtreemfs.pbrpc.ObjectList object_set = 2; + for (int i = 0; i < this->object_set_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->object_set(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* InternalReadLocalResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.ObjectData data = 1; + if (has_data()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->data(), target); + } + + // repeated .xtreemfs.pbrpc.ObjectList object_set = 2; + for (int i = 0; i < this->object_set_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->object_set(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int InternalReadLocalResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.ObjectData data = 1; + if (has_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->data()); + } + + } + // repeated .xtreemfs.pbrpc.ObjectList object_set = 2; + total_size += 1 * this->object_set_size(); + for (int i = 0; i < this->object_set_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->object_set(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void InternalReadLocalResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const InternalReadLocalResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void InternalReadLocalResponse::MergeFrom(const InternalReadLocalResponse& from) { + GOOGLE_CHECK_NE(&from, this); + object_set_.MergeFrom(from.object_set_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_data()) { + mutable_data()->::xtreemfs::pbrpc::ObjectData::MergeFrom(from.data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void InternalReadLocalResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InternalReadLocalResponse::CopyFrom(const InternalReadLocalResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InternalReadLocalResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_data()) { + if (!this->data().IsInitialized()) return false; + } + for (int i = 0; i < object_set_size(); i++) { + if (!this->object_set(i).IsInitialized()) return false; + } + return true; +} + +void InternalReadLocalResponse::Swap(InternalReadLocalResponse* other) { + if (other != this) { + std::swap(data_, other->data_); + object_set_.Swap(&other->object_set_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata InternalReadLocalResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = InternalReadLocalResponse_descriptor_; + metadata.reflection = InternalReadLocalResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int readRequest::kFileCredentialsFieldNumber; +const int readRequest::kFileIdFieldNumber; +const int readRequest::kObjectNumberFieldNumber; +const int readRequest::kObjectVersionFieldNumber; +const int readRequest::kOffsetFieldNumber; +const int readRequest::kLengthFieldNumber; +#endif // !_MSC_VER + +readRequest::readRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void readRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +readRequest::readRequest(const readRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void readRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + offset_ = 0u; + length_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +readRequest::~readRequest() { + SharedDtor(); +} + +void readRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void readRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* readRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return readRequest_descriptor_; +} + +const readRequest& readRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +readRequest* readRequest::default_instance_ = NULL; + +readRequest* readRequest::New() const { + return new readRequest; +} + +void readRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + offset_ = 0u; + length_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool readRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_object_number; + break; + } + + // required fixed64 object_number = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_number: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_offset; + break; + } + + // required fixed32 offset = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &offset_))); + set_has_offset(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(53)) goto parse_length; + break; + } + + // required fixed32 length = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &length_))); + set_has_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void readRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->object_number(), output); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output); + } + + // required fixed32 offset = 5; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->offset(), output); + } + + // required fixed32 length = 6; + if (has_length()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(6, this->length(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* readRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->object_number(), target); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target); + } + + // required fixed32 offset = 5; + if (has_offset()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->offset(), target); + } + + // required fixed32 length = 6; + if (has_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(6, this->length(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int readRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + total_size += 1 + 8; + } + + // required fixed32 offset = 5; + if (has_offset()) { + total_size += 1 + 4; + } + + // required fixed32 length = 6; + if (has_length()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void readRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const readRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void readRequest::MergeFrom(const readRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + if (from.has_offset()) { + set_offset(from.offset()); + } + if (from.has_length()) { + set_length(from.length()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void readRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void readRequest::CopyFrom(const readRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool readRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void readRequest::Swap(readRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + std::swap(offset_, other->offset_); + std::swap(length_, other->length_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata readRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = readRequest_descriptor_; + metadata.reflection = readRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int truncateRequest::kFileCredentialsFieldNumber; +const int truncateRequest::kFileIdFieldNumber; +const int truncateRequest::kNewFileSizeFieldNumber; +#endif // !_MSC_VER + +truncateRequest::truncateRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void truncateRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +truncateRequest::truncateRequest(const truncateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void truncateRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + new_file_size_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +truncateRequest::~truncateRequest() { + SharedDtor(); +} + +void truncateRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void truncateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* truncateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return truncateRequest_descriptor_; +} + +const truncateRequest& truncateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +truncateRequest* truncateRequest::default_instance_ = NULL; + +truncateRequest* truncateRequest::New() const { + return new truncateRequest; +} + +void truncateRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + new_file_size_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool truncateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_new_file_size; + break; + } + + // required fixed64 new_file_size = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_new_file_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &new_file_size_))); + set_has_new_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void truncateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->new_file_size(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* truncateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->new_file_size(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int truncateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void truncateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const truncateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void truncateRequest::MergeFrom(const truncateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_new_file_size()) { + set_new_file_size(from.new_file_size()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void truncateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void truncateRequest::CopyFrom(const truncateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool truncateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void truncateRequest::Swap(truncateRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(new_file_size_, other->new_file_size_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata truncateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = truncateRequest_descriptor_; + metadata.reflection = truncateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int unlink_osd_Request::kFileCredentialsFieldNumber; +const int unlink_osd_Request::kFileIdFieldNumber; +#endif // !_MSC_VER + +unlink_osd_Request::unlink_osd_Request() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void unlink_osd_Request::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +unlink_osd_Request::unlink_osd_Request(const unlink_osd_Request& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void unlink_osd_Request::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +unlink_osd_Request::~unlink_osd_Request() { + SharedDtor(); +} + +void unlink_osd_Request::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void unlink_osd_Request::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* unlink_osd_Request::descriptor() { + protobuf_AssignDescriptorsOnce(); + return unlink_osd_Request_descriptor_; +} + +const unlink_osd_Request& unlink_osd_Request::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +unlink_osd_Request* unlink_osd_Request::default_instance_ = NULL; + +unlink_osd_Request* unlink_osd_Request::New() const { + return new unlink_osd_Request; +} + +void unlink_osd_Request::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool unlink_osd_Request::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void unlink_osd_Request::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* unlink_osd_Request::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int unlink_osd_Request::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void unlink_osd_Request::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const unlink_osd_Request* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void unlink_osd_Request::MergeFrom(const unlink_osd_Request& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void unlink_osd_Request::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void unlink_osd_Request::CopyFrom(const unlink_osd_Request& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool unlink_osd_Request::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void unlink_osd_Request::Swap(unlink_osd_Request* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata unlink_osd_Request::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = unlink_osd_Request_descriptor_; + metadata.reflection = unlink_osd_Request_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int writeRequest::kFileCredentialsFieldNumber; +const int writeRequest::kFileIdFieldNumber; +const int writeRequest::kObjectNumberFieldNumber; +const int writeRequest::kObjectVersionFieldNumber; +const int writeRequest::kOffsetFieldNumber; +const int writeRequest::kLeaseTimeoutFieldNumber; +const int writeRequest::kObjectDataFieldNumber; +#endif // !_MSC_VER + +writeRequest::writeRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void writeRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); + object_data_ = const_cast< ::xtreemfs::pbrpc::ObjectData*>(&::xtreemfs::pbrpc::ObjectData::default_instance()); +} + +writeRequest::writeRequest(const writeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void writeRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + offset_ = 0u; + lease_timeout_ = GOOGLE_ULONGLONG(0); + object_data_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +writeRequest::~writeRequest() { + SharedDtor(); +} + +void writeRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + delete object_data_; + } +} + +void writeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* writeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return writeRequest_descriptor_; +} + +const writeRequest& writeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +writeRequest* writeRequest::default_instance_ = NULL; + +writeRequest* writeRequest::New() const { + return new writeRequest; +} + +void writeRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + offset_ = 0u; + lease_timeout_ = GOOGLE_ULONGLONG(0); + if (has_object_data()) { + if (object_data_ != NULL) object_data_->::xtreemfs::pbrpc::ObjectData::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool writeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_object_number; + break; + } + + // required fixed64 object_number = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_number: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_offset; + break; + } + + // required fixed32 offset = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &offset_))); + set_has_offset(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(49)) goto parse_lease_timeout; + break; + } + + // required fixed64 lease_timeout = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_lease_timeout: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &lease_timeout_))); + set_has_lease_timeout(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(58)) goto parse_object_data; + break; + } + + // required .xtreemfs.pbrpc.ObjectData object_data = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_object_data: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_object_data())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void writeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->object_number(), output); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output); + } + + // required fixed32 offset = 5; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->offset(), output); + } + + // required fixed64 lease_timeout = 6; + if (has_lease_timeout()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(6, this->lease_timeout(), output); + } + + // required .xtreemfs.pbrpc.ObjectData object_data = 7; + if (has_object_data()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, this->object_data(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* writeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->object_number(), target); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target); + } + + // required fixed32 offset = 5; + if (has_offset()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->offset(), target); + } + + // required fixed64 lease_timeout = 6; + if (has_lease_timeout()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(6, this->lease_timeout(), target); + } + + // required .xtreemfs.pbrpc.ObjectData object_data = 7; + if (has_object_data()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 7, this->object_data(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int writeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + total_size += 1 + 8; + } + + // required fixed32 offset = 5; + if (has_offset()) { + total_size += 1 + 4; + } + + // required fixed64 lease_timeout = 6; + if (has_lease_timeout()) { + total_size += 1 + 8; + } + + // required .xtreemfs.pbrpc.ObjectData object_data = 7; + if (has_object_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->object_data()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void writeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const writeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void writeRequest::MergeFrom(const writeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + if (from.has_offset()) { + set_offset(from.offset()); + } + if (from.has_lease_timeout()) { + set_lease_timeout(from.lease_timeout()); + } + if (from.has_object_data()) { + mutable_object_data()->::xtreemfs::pbrpc::ObjectData::MergeFrom(from.object_data()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void writeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void writeRequest::CopyFrom(const writeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool writeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000007f) != 0x0000007f) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + if (has_object_data()) { + if (!this->object_data().IsInitialized()) return false; + } + return true; +} + +void writeRequest::Swap(writeRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + std::swap(offset_, other->offset_); + std::swap(lease_timeout_, other->lease_timeout_); + std::swap(object_data_, other->object_data_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata writeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = writeRequest_descriptor_; + metadata.reflection = writeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_broadcast_gmaxRequest::kFileIdFieldNumber; +const int xtreemfs_broadcast_gmaxRequest::kTruncateEpochFieldNumber; +const int xtreemfs_broadcast_gmaxRequest::kLastObjectFieldNumber; +const int xtreemfs_broadcast_gmaxRequest::kFileSizeFieldNumber; +#endif // !_MSC_VER + +xtreemfs_broadcast_gmaxRequest::xtreemfs_broadcast_gmaxRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_broadcast_gmaxRequest::InitAsDefaultInstance() { +} + +xtreemfs_broadcast_gmaxRequest::xtreemfs_broadcast_gmaxRequest(const xtreemfs_broadcast_gmaxRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_broadcast_gmaxRequest::SharedCtor() { + _cached_size_ = 0; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + truncate_epoch_ = GOOGLE_ULONGLONG(0); + last_object_ = GOOGLE_ULONGLONG(0); + file_size_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_broadcast_gmaxRequest::~xtreemfs_broadcast_gmaxRequest() { + SharedDtor(); +} + +void xtreemfs_broadcast_gmaxRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_broadcast_gmaxRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_broadcast_gmaxRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_broadcast_gmaxRequest_descriptor_; +} + +const xtreemfs_broadcast_gmaxRequest& xtreemfs_broadcast_gmaxRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_broadcast_gmaxRequest* xtreemfs_broadcast_gmaxRequest::default_instance_ = NULL; + +xtreemfs_broadcast_gmaxRequest* xtreemfs_broadcast_gmaxRequest::New() const { + return new xtreemfs_broadcast_gmaxRequest; +} + +void xtreemfs_broadcast_gmaxRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + truncate_epoch_ = GOOGLE_ULONGLONG(0); + last_object_ = GOOGLE_ULONGLONG(0); + file_size_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_broadcast_gmaxRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string file_id = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_truncate_epoch; + break; + } + + // required fixed64 truncate_epoch = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_truncate_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &truncate_epoch_))); + set_has_truncate_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_last_object; + break; + } + + // required fixed64 last_object = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_last_object: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &last_object_))); + set_has_last_object(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_file_size; + break; + } + + // required fixed64 file_size = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_file_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &file_size_))); + set_has_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_broadcast_gmaxRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_id(), output); + } + + // required fixed64 truncate_epoch = 2; + if (has_truncate_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->truncate_epoch(), output); + } + + // required fixed64 last_object = 3; + if (has_last_object()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->last_object(), output); + } + + // required fixed64 file_size = 4; + if (has_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->file_size(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_broadcast_gmaxRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string file_id = 1; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->file_id(), target); + } + + // required fixed64 truncate_epoch = 2; + if (has_truncate_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->truncate_epoch(), target); + } + + // required fixed64 last_object = 3; + if (has_last_object()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->last_object(), target); + } + + // required fixed64 file_size = 4; + if (has_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->file_size(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_broadcast_gmaxRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string file_id = 1; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 truncate_epoch = 2; + if (has_truncate_epoch()) { + total_size += 1 + 8; + } + + // required fixed64 last_object = 3; + if (has_last_object()) { + total_size += 1 + 8; + } + + // required fixed64 file_size = 4; + if (has_file_size()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_broadcast_gmaxRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_broadcast_gmaxRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_broadcast_gmaxRequest::MergeFrom(const xtreemfs_broadcast_gmaxRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_truncate_epoch()) { + set_truncate_epoch(from.truncate_epoch()); + } + if (from.has_last_object()) { + set_last_object(from.last_object()); + } + if (from.has_file_size()) { + set_file_size(from.file_size()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_broadcast_gmaxRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_broadcast_gmaxRequest::CopyFrom(const xtreemfs_broadcast_gmaxRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_broadcast_gmaxRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + return true; +} + +void xtreemfs_broadcast_gmaxRequest::Swap(xtreemfs_broadcast_gmaxRequest* other) { + if (other != this) { + std::swap(file_id_, other->file_id_); + std::swap(truncate_epoch_, other->truncate_epoch_); + std::swap(last_object_, other->last_object_); + std::swap(file_size_, other->file_size_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_broadcast_gmaxRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_broadcast_gmaxRequest_descriptor_; + metadata.reflection = xtreemfs_broadcast_gmaxRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_check_objectRequest::kFileCredentialsFieldNumber; +const int xtreemfs_check_objectRequest::kFileIdFieldNumber; +const int xtreemfs_check_objectRequest::kObjectNumberFieldNumber; +const int xtreemfs_check_objectRequest::kObjectVersionFieldNumber; +#endif // !_MSC_VER + +xtreemfs_check_objectRequest::xtreemfs_check_objectRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_check_objectRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_check_objectRequest::xtreemfs_check_objectRequest(const xtreemfs_check_objectRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_check_objectRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_check_objectRequest::~xtreemfs_check_objectRequest() { + SharedDtor(); +} + +void xtreemfs_check_objectRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_check_objectRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_check_objectRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_check_objectRequest_descriptor_; +} + +const xtreemfs_check_objectRequest& xtreemfs_check_objectRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_check_objectRequest* xtreemfs_check_objectRequest::default_instance_ = NULL; + +xtreemfs_check_objectRequest* xtreemfs_check_objectRequest::New() const { + return new xtreemfs_check_objectRequest; +} + +void xtreemfs_check_objectRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_check_objectRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_object_number; + break; + } + + // required fixed64 object_number = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_number: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_check_objectRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->object_number(), output); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_check_objectRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->object_number(), target); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_check_objectRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_check_objectRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_check_objectRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_check_objectRequest::MergeFrom(const xtreemfs_check_objectRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_check_objectRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_check_objectRequest::CopyFrom(const xtreemfs_check_objectRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_check_objectRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_check_objectRequest::Swap(xtreemfs_check_objectRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_check_objectRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_check_objectRequest_descriptor_; + metadata.reflection = xtreemfs_check_objectRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_cleanup_get_resultsResponse::kResultsFieldNumber; +#endif // !_MSC_VER + +xtreemfs_cleanup_get_resultsResponse::xtreemfs_cleanup_get_resultsResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_cleanup_get_resultsResponse::InitAsDefaultInstance() { +} + +xtreemfs_cleanup_get_resultsResponse::xtreemfs_cleanup_get_resultsResponse(const xtreemfs_cleanup_get_resultsResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_cleanup_get_resultsResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_cleanup_get_resultsResponse::~xtreemfs_cleanup_get_resultsResponse() { + SharedDtor(); +} + +void xtreemfs_cleanup_get_resultsResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_cleanup_get_resultsResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_cleanup_get_resultsResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_cleanup_get_resultsResponse_descriptor_; +} + +const xtreemfs_cleanup_get_resultsResponse& xtreemfs_cleanup_get_resultsResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_cleanup_get_resultsResponse* xtreemfs_cleanup_get_resultsResponse::default_instance_ = NULL; + +xtreemfs_cleanup_get_resultsResponse* xtreemfs_cleanup_get_resultsResponse::New() const { + return new xtreemfs_cleanup_get_resultsResponse; +} + +void xtreemfs_cleanup_get_resultsResponse::Clear() { + results_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_cleanup_get_resultsResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string results = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_results: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_results())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->results(this->results_size() - 1).data(), + this->results(this->results_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_results; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_cleanup_get_resultsResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated string results = 1; + for (int i = 0; i < this->results_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->results(i).data(), this->results(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->results(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_cleanup_get_resultsResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated string results = 1; + for (int i = 0; i < this->results_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->results(i).data(), this->results(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1, this->results(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_cleanup_get_resultsResponse::ByteSize() const { + int total_size = 0; + + // repeated string results = 1; + total_size += 1 * this->results_size(); + for (int i = 0; i < this->results_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->results(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_cleanup_get_resultsResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_cleanup_get_resultsResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_cleanup_get_resultsResponse::MergeFrom(const xtreemfs_cleanup_get_resultsResponse& from) { + GOOGLE_CHECK_NE(&from, this); + results_.MergeFrom(from.results_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_cleanup_get_resultsResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_cleanup_get_resultsResponse::CopyFrom(const xtreemfs_cleanup_get_resultsResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_cleanup_get_resultsResponse::IsInitialized() const { + + return true; +} + +void xtreemfs_cleanup_get_resultsResponse::Swap(xtreemfs_cleanup_get_resultsResponse* other) { + if (other != this) { + results_.Swap(&other->results_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_cleanup_get_resultsResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_cleanup_get_resultsResponse_descriptor_; + metadata.reflection = xtreemfs_cleanup_get_resultsResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_cleanup_is_runningResponse::kIsRunningFieldNumber; +#endif // !_MSC_VER + +xtreemfs_cleanup_is_runningResponse::xtreemfs_cleanup_is_runningResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_cleanup_is_runningResponse::InitAsDefaultInstance() { +} + +xtreemfs_cleanup_is_runningResponse::xtreemfs_cleanup_is_runningResponse(const xtreemfs_cleanup_is_runningResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_cleanup_is_runningResponse::SharedCtor() { + _cached_size_ = 0; + is_running_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_cleanup_is_runningResponse::~xtreemfs_cleanup_is_runningResponse() { + SharedDtor(); +} + +void xtreemfs_cleanup_is_runningResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_cleanup_is_runningResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_cleanup_is_runningResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_cleanup_is_runningResponse_descriptor_; +} + +const xtreemfs_cleanup_is_runningResponse& xtreemfs_cleanup_is_runningResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_cleanup_is_runningResponse* xtreemfs_cleanup_is_runningResponse::default_instance_ = NULL; + +xtreemfs_cleanup_is_runningResponse* xtreemfs_cleanup_is_runningResponse::New() const { + return new xtreemfs_cleanup_is_runningResponse; +} + +void xtreemfs_cleanup_is_runningResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + is_running_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_cleanup_is_runningResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required bool is_running = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &is_running_))); + set_has_is_running(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_cleanup_is_runningResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required bool is_running = 1; + if (has_is_running()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->is_running(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_cleanup_is_runningResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required bool is_running = 1; + if (has_is_running()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->is_running(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_cleanup_is_runningResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required bool is_running = 1; + if (has_is_running()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_cleanup_is_runningResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_cleanup_is_runningResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_cleanup_is_runningResponse::MergeFrom(const xtreemfs_cleanup_is_runningResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_is_running()) { + set_is_running(from.is_running()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_cleanup_is_runningResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_cleanup_is_runningResponse::CopyFrom(const xtreemfs_cleanup_is_runningResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_cleanup_is_runningResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_cleanup_is_runningResponse::Swap(xtreemfs_cleanup_is_runningResponse* other) { + if (other != this) { + std::swap(is_running_, other->is_running_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_cleanup_is_runningResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_cleanup_is_runningResponse_descriptor_; + metadata.reflection = xtreemfs_cleanup_is_runningResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_cleanup_startRequest::kRemoveZombiesFieldNumber; +const int xtreemfs_cleanup_startRequest::kRemoveUnavailVolumeFieldNumber; +const int xtreemfs_cleanup_startRequest::kLostAndFoundFieldNumber; +const int xtreemfs_cleanup_startRequest::kDeleteMetadataFieldNumber; +const int xtreemfs_cleanup_startRequest::kMetadataTimeoutFieldNumber; +#endif // !_MSC_VER + +xtreemfs_cleanup_startRequest::xtreemfs_cleanup_startRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_cleanup_startRequest::InitAsDefaultInstance() { +} + +xtreemfs_cleanup_startRequest::xtreemfs_cleanup_startRequest(const xtreemfs_cleanup_startRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_cleanup_startRequest::SharedCtor() { + _cached_size_ = 0; + remove_zombies_ = false; + remove_unavail_volume_ = false; + lost_and_found_ = false; + delete_metadata_ = false; + metadata_timeout_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_cleanup_startRequest::~xtreemfs_cleanup_startRequest() { + SharedDtor(); +} + +void xtreemfs_cleanup_startRequest::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_cleanup_startRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_cleanup_startRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_cleanup_startRequest_descriptor_; +} + +const xtreemfs_cleanup_startRequest& xtreemfs_cleanup_startRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_cleanup_startRequest* xtreemfs_cleanup_startRequest::default_instance_ = NULL; + +xtreemfs_cleanup_startRequest* xtreemfs_cleanup_startRequest::New() const { + return new xtreemfs_cleanup_startRequest; +} + +void xtreemfs_cleanup_startRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + remove_zombies_ = false; + remove_unavail_volume_ = false; + lost_and_found_ = false; + delete_metadata_ = false; + metadata_timeout_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_cleanup_startRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required bool remove_zombies = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &remove_zombies_))); + set_has_remove_zombies(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_remove_unavail_volume; + break; + } + + // required bool remove_unavail_volume = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_remove_unavail_volume: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &remove_unavail_volume_))); + set_has_remove_unavail_volume(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_lost_and_found; + break; + } + + // required bool lost_and_found = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_lost_and_found: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &lost_and_found_))); + set_has_lost_and_found(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_delete_metadata; + break; + } + + // required bool delete_metadata = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_delete_metadata: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &delete_metadata_))); + set_has_delete_metadata(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_metadata_timeout; + break; + } + + // required fixed32 metadata_timeout = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_metadata_timeout: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &metadata_timeout_))); + set_has_metadata_timeout(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_cleanup_startRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required bool remove_zombies = 1; + if (has_remove_zombies()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->remove_zombies(), output); + } + + // required bool remove_unavail_volume = 2; + if (has_remove_unavail_volume()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->remove_unavail_volume(), output); + } + + // required bool lost_and_found = 3; + if (has_lost_and_found()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->lost_and_found(), output); + } + + // required bool delete_metadata = 4; + if (has_delete_metadata()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->delete_metadata(), output); + } + + // required fixed32 metadata_timeout = 5; + if (has_metadata_timeout()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->metadata_timeout(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_cleanup_startRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required bool remove_zombies = 1; + if (has_remove_zombies()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->remove_zombies(), target); + } + + // required bool remove_unavail_volume = 2; + if (has_remove_unavail_volume()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->remove_unavail_volume(), target); + } + + // required bool lost_and_found = 3; + if (has_lost_and_found()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->lost_and_found(), target); + } + + // required bool delete_metadata = 4; + if (has_delete_metadata()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->delete_metadata(), target); + } + + // required fixed32 metadata_timeout = 5; + if (has_metadata_timeout()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->metadata_timeout(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_cleanup_startRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required bool remove_zombies = 1; + if (has_remove_zombies()) { + total_size += 1 + 1; + } + + // required bool remove_unavail_volume = 2; + if (has_remove_unavail_volume()) { + total_size += 1 + 1; + } + + // required bool lost_and_found = 3; + if (has_lost_and_found()) { + total_size += 1 + 1; + } + + // required bool delete_metadata = 4; + if (has_delete_metadata()) { + total_size += 1 + 1; + } + + // required fixed32 metadata_timeout = 5; + if (has_metadata_timeout()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_cleanup_startRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_cleanup_startRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_cleanup_startRequest::MergeFrom(const xtreemfs_cleanup_startRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_remove_zombies()) { + set_remove_zombies(from.remove_zombies()); + } + if (from.has_remove_unavail_volume()) { + set_remove_unavail_volume(from.remove_unavail_volume()); + } + if (from.has_lost_and_found()) { + set_lost_and_found(from.lost_and_found()); + } + if (from.has_delete_metadata()) { + set_delete_metadata(from.delete_metadata()); + } + if (from.has_metadata_timeout()) { + set_metadata_timeout(from.metadata_timeout()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_cleanup_startRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_cleanup_startRequest::CopyFrom(const xtreemfs_cleanup_startRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_cleanup_startRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false; + + return true; +} + +void xtreemfs_cleanup_startRequest::Swap(xtreemfs_cleanup_startRequest* other) { + if (other != this) { + std::swap(remove_zombies_, other->remove_zombies_); + std::swap(remove_unavail_volume_, other->remove_unavail_volume_); + std::swap(lost_and_found_, other->lost_and_found_); + std::swap(delete_metadata_, other->delete_metadata_); + std::swap(metadata_timeout_, other->metadata_timeout_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_cleanup_startRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_cleanup_startRequest_descriptor_; + metadata.reflection = xtreemfs_cleanup_startRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_cleanup_statusResponse::kStatusFieldNumber; +#endif // !_MSC_VER + +xtreemfs_cleanup_statusResponse::xtreemfs_cleanup_statusResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_cleanup_statusResponse::InitAsDefaultInstance() { +} + +xtreemfs_cleanup_statusResponse::xtreemfs_cleanup_statusResponse(const xtreemfs_cleanup_statusResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_cleanup_statusResponse::SharedCtor() { + _cached_size_ = 0; + status_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_cleanup_statusResponse::~xtreemfs_cleanup_statusResponse() { + SharedDtor(); +} + +void xtreemfs_cleanup_statusResponse::SharedDtor() { + if (status_ != &::google::protobuf::internal::kEmptyString) { + delete status_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_cleanup_statusResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_cleanup_statusResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_cleanup_statusResponse_descriptor_; +} + +const xtreemfs_cleanup_statusResponse& xtreemfs_cleanup_statusResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_cleanup_statusResponse* xtreemfs_cleanup_statusResponse::default_instance_ = NULL; + +xtreemfs_cleanup_statusResponse* xtreemfs_cleanup_statusResponse::New() const { + return new xtreemfs_cleanup_statusResponse; +} + +void xtreemfs_cleanup_statusResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_status()) { + if (status_ != &::google::protobuf::internal::kEmptyString) { + status_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_cleanup_statusResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string status = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_status())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->status().data(), this->status().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_cleanup_statusResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string status = 1; + if (has_status()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->status().data(), this->status().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->status(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_cleanup_statusResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string status = 1; + if (has_status()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->status().data(), this->status().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->status(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_cleanup_statusResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string status = 1; + if (has_status()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->status()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_cleanup_statusResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_cleanup_statusResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_cleanup_statusResponse::MergeFrom(const xtreemfs_cleanup_statusResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_status()) { + set_status(from.status()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_cleanup_statusResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_cleanup_statusResponse::CopyFrom(const xtreemfs_cleanup_statusResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_cleanup_statusResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_cleanup_statusResponse::Swap(xtreemfs_cleanup_statusResponse* other) { + if (other != this) { + std::swap(status_, other->status_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_cleanup_statusResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_cleanup_statusResponse_descriptor_; + metadata.reflection = xtreemfs_cleanup_statusResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rwr_fetchRequest::kFileCredentialsFieldNumber; +const int xtreemfs_rwr_fetchRequest::kFileIdFieldNumber; +const int xtreemfs_rwr_fetchRequest::kObjectNumberFieldNumber; +const int xtreemfs_rwr_fetchRequest::kObjectVersionFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rwr_fetchRequest::xtreemfs_rwr_fetchRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rwr_fetchRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_rwr_fetchRequest::xtreemfs_rwr_fetchRequest(const xtreemfs_rwr_fetchRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rwr_fetchRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rwr_fetchRequest::~xtreemfs_rwr_fetchRequest() { + SharedDtor(); +} + +void xtreemfs_rwr_fetchRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_rwr_fetchRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rwr_fetchRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rwr_fetchRequest_descriptor_; +} + +const xtreemfs_rwr_fetchRequest& xtreemfs_rwr_fetchRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_rwr_fetchRequest* xtreemfs_rwr_fetchRequest::default_instance_ = NULL; + +xtreemfs_rwr_fetchRequest* xtreemfs_rwr_fetchRequest::New() const { + return new xtreemfs_rwr_fetchRequest; +} + +void xtreemfs_rwr_fetchRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rwr_fetchRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_object_number; + break; + } + + // required fixed64 object_number = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_number: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rwr_fetchRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->object_number(), output); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rwr_fetchRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->object_number(), target); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rwr_fetchRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rwr_fetchRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rwr_fetchRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rwr_fetchRequest::MergeFrom(const xtreemfs_rwr_fetchRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rwr_fetchRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rwr_fetchRequest::CopyFrom(const xtreemfs_rwr_fetchRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rwr_fetchRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_rwr_fetchRequest::Swap(xtreemfs_rwr_fetchRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rwr_fetchRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rwr_fetchRequest_descriptor_; + metadata.reflection = xtreemfs_rwr_fetchRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_repair_objectRequest::kFileCredentialsFieldNumber; +const int xtreemfs_repair_objectRequest::kFileIdFieldNumber; +const int xtreemfs_repair_objectRequest::kObjectNumberFieldNumber; +const int xtreemfs_repair_objectRequest::kObjectVersionFieldNumber; +#endif // !_MSC_VER + +xtreemfs_repair_objectRequest::xtreemfs_repair_objectRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_repair_objectRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_repair_objectRequest::xtreemfs_repair_objectRequest(const xtreemfs_repair_objectRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_repair_objectRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_repair_objectRequest::~xtreemfs_repair_objectRequest() { + SharedDtor(); +} + +void xtreemfs_repair_objectRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_repair_objectRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_repair_objectRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_repair_objectRequest_descriptor_; +} + +const xtreemfs_repair_objectRequest& xtreemfs_repair_objectRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_repair_objectRequest* xtreemfs_repair_objectRequest::default_instance_ = NULL; + +xtreemfs_repair_objectRequest* xtreemfs_repair_objectRequest::New() const { + return new xtreemfs_repair_objectRequest; +} + +void xtreemfs_repair_objectRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_repair_objectRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_object_number; + break; + } + + // required fixed64 object_number = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_number: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_repair_objectRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->object_number(), output); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_repair_objectRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->object_number(), target); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_repair_objectRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_repair_objectRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_repair_objectRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_repair_objectRequest::MergeFrom(const xtreemfs_repair_objectRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_repair_objectRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_repair_objectRequest::CopyFrom(const xtreemfs_repair_objectRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_repair_objectRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_repair_objectRequest::Swap(xtreemfs_repair_objectRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_repair_objectRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_repair_objectRequest_descriptor_; + metadata.reflection = xtreemfs_repair_objectRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rwr_flease_msgRequest::kSenderHostnameFieldNumber; +const int xtreemfs_rwr_flease_msgRequest::kSenderPortFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rwr_flease_msgRequest::xtreemfs_rwr_flease_msgRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rwr_flease_msgRequest::InitAsDefaultInstance() { +} + +xtreemfs_rwr_flease_msgRequest::xtreemfs_rwr_flease_msgRequest(const xtreemfs_rwr_flease_msgRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rwr_flease_msgRequest::SharedCtor() { + _cached_size_ = 0; + sender_hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + sender_port_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rwr_flease_msgRequest::~xtreemfs_rwr_flease_msgRequest() { + SharedDtor(); +} + +void xtreemfs_rwr_flease_msgRequest::SharedDtor() { + if (sender_hostname_ != &::google::protobuf::internal::kEmptyString) { + delete sender_hostname_; + } + if (this != default_instance_) { + } +} + +void xtreemfs_rwr_flease_msgRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rwr_flease_msgRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rwr_flease_msgRequest_descriptor_; +} + +const xtreemfs_rwr_flease_msgRequest& xtreemfs_rwr_flease_msgRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_rwr_flease_msgRequest* xtreemfs_rwr_flease_msgRequest::default_instance_ = NULL; + +xtreemfs_rwr_flease_msgRequest* xtreemfs_rwr_flease_msgRequest::New() const { + return new xtreemfs_rwr_flease_msgRequest; +} + +void xtreemfs_rwr_flease_msgRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_sender_hostname()) { + if (sender_hostname_ != &::google::protobuf::internal::kEmptyString) { + sender_hostname_->clear(); + } + } + sender_port_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rwr_flease_msgRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string sender_hostname = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_sender_hostname())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->sender_hostname().data(), this->sender_hostname().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(21)) goto parse_sender_port; + break; + } + + // required fixed32 sender_port = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_sender_port: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &sender_port_))); + set_has_sender_port(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rwr_flease_msgRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string sender_hostname = 1; + if (has_sender_hostname()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->sender_hostname().data(), this->sender_hostname().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->sender_hostname(), output); + } + + // required fixed32 sender_port = 2; + if (has_sender_port()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->sender_port(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rwr_flease_msgRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string sender_hostname = 1; + if (has_sender_hostname()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->sender_hostname().data(), this->sender_hostname().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->sender_hostname(), target); + } + + // required fixed32 sender_port = 2; + if (has_sender_port()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->sender_port(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rwr_flease_msgRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string sender_hostname = 1; + if (has_sender_hostname()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->sender_hostname()); + } + + // required fixed32 sender_port = 2; + if (has_sender_port()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rwr_flease_msgRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rwr_flease_msgRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rwr_flease_msgRequest::MergeFrom(const xtreemfs_rwr_flease_msgRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_sender_hostname()) { + set_sender_hostname(from.sender_hostname()); + } + if (from.has_sender_port()) { + set_sender_port(from.sender_port()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rwr_flease_msgRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rwr_flease_msgRequest::CopyFrom(const xtreemfs_rwr_flease_msgRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rwr_flease_msgRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void xtreemfs_rwr_flease_msgRequest::Swap(xtreemfs_rwr_flease_msgRequest* other) { + if (other != this) { + std::swap(sender_hostname_, other->sender_hostname_); + std::swap(sender_port_, other->sender_port_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rwr_flease_msgRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rwr_flease_msgRequest_descriptor_; + metadata.reflection = xtreemfs_rwr_flease_msgRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rwr_set_primary_epochRequest::kFileCredentialsFieldNumber; +const int xtreemfs_rwr_set_primary_epochRequest::kFileIdFieldNumber; +const int xtreemfs_rwr_set_primary_epochRequest::kPrimaryEpochFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rwr_set_primary_epochRequest::xtreemfs_rwr_set_primary_epochRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rwr_set_primary_epochRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_rwr_set_primary_epochRequest::xtreemfs_rwr_set_primary_epochRequest(const xtreemfs_rwr_set_primary_epochRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rwr_set_primary_epochRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + primary_epoch_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rwr_set_primary_epochRequest::~xtreemfs_rwr_set_primary_epochRequest() { + SharedDtor(); +} + +void xtreemfs_rwr_set_primary_epochRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_rwr_set_primary_epochRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rwr_set_primary_epochRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rwr_set_primary_epochRequest_descriptor_; +} + +const xtreemfs_rwr_set_primary_epochRequest& xtreemfs_rwr_set_primary_epochRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_rwr_set_primary_epochRequest* xtreemfs_rwr_set_primary_epochRequest::default_instance_ = NULL; + +xtreemfs_rwr_set_primary_epochRequest* xtreemfs_rwr_set_primary_epochRequest::New() const { + return new xtreemfs_rwr_set_primary_epochRequest; +} + +void xtreemfs_rwr_set_primary_epochRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + primary_epoch_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rwr_set_primary_epochRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_primary_epoch; + break; + } + + // required fixed32 primary_epoch = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_primary_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &primary_epoch_))); + set_has_primary_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rwr_set_primary_epochRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed32 primary_epoch = 3; + if (has_primary_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->primary_epoch(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rwr_set_primary_epochRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed32 primary_epoch = 3; + if (has_primary_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->primary_epoch(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rwr_set_primary_epochRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed32 primary_epoch = 3; + if (has_primary_epoch()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rwr_set_primary_epochRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rwr_set_primary_epochRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rwr_set_primary_epochRequest::MergeFrom(const xtreemfs_rwr_set_primary_epochRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_primary_epoch()) { + set_primary_epoch(from.primary_epoch()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rwr_set_primary_epochRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rwr_set_primary_epochRequest::CopyFrom(const xtreemfs_rwr_set_primary_epochRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rwr_set_primary_epochRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_rwr_set_primary_epochRequest::Swap(xtreemfs_rwr_set_primary_epochRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(primary_epoch_, other->primary_epoch_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rwr_set_primary_epochRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rwr_set_primary_epochRequest_descriptor_; + metadata.reflection = xtreemfs_rwr_set_primary_epochRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rwr_statusRequest::kFileCredentialsFieldNumber; +const int xtreemfs_rwr_statusRequest::kFileIdFieldNumber; +const int xtreemfs_rwr_statusRequest::kMaxLocalObjVersionFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rwr_statusRequest::xtreemfs_rwr_statusRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rwr_statusRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_rwr_statusRequest::xtreemfs_rwr_statusRequest(const xtreemfs_rwr_statusRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rwr_statusRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + max_local_obj_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rwr_statusRequest::~xtreemfs_rwr_statusRequest() { + SharedDtor(); +} + +void xtreemfs_rwr_statusRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_rwr_statusRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rwr_statusRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rwr_statusRequest_descriptor_; +} + +const xtreemfs_rwr_statusRequest& xtreemfs_rwr_statusRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_rwr_statusRequest* xtreemfs_rwr_statusRequest::default_instance_ = NULL; + +xtreemfs_rwr_statusRequest* xtreemfs_rwr_statusRequest::New() const { + return new xtreemfs_rwr_statusRequest; +} + +void xtreemfs_rwr_statusRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + max_local_obj_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rwr_statusRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_max_local_obj_version; + break; + } + + // required fixed64 max_local_obj_version = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_max_local_obj_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &max_local_obj_version_))); + set_has_max_local_obj_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rwr_statusRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 max_local_obj_version = 3; + if (has_max_local_obj_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->max_local_obj_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rwr_statusRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 max_local_obj_version = 3; + if (has_max_local_obj_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->max_local_obj_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rwr_statusRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 max_local_obj_version = 3; + if (has_max_local_obj_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rwr_statusRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rwr_statusRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rwr_statusRequest::MergeFrom(const xtreemfs_rwr_statusRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_max_local_obj_version()) { + set_max_local_obj_version(from.max_local_obj_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rwr_statusRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rwr_statusRequest::CopyFrom(const xtreemfs_rwr_statusRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rwr_statusRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_rwr_statusRequest::Swap(xtreemfs_rwr_statusRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(max_local_obj_version_, other->max_local_obj_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rwr_statusRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rwr_statusRequest_descriptor_; + metadata.reflection = xtreemfs_rwr_statusRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rwr_truncateRequest::kFileCredentialsFieldNumber; +const int xtreemfs_rwr_truncateRequest::kFileIdFieldNumber; +const int xtreemfs_rwr_truncateRequest::kNewFileSizeFieldNumber; +const int xtreemfs_rwr_truncateRequest::kObjectVersionFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rwr_truncateRequest::xtreemfs_rwr_truncateRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rwr_truncateRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_rwr_truncateRequest::xtreemfs_rwr_truncateRequest(const xtreemfs_rwr_truncateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rwr_truncateRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + new_file_size_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rwr_truncateRequest::~xtreemfs_rwr_truncateRequest() { + SharedDtor(); +} + +void xtreemfs_rwr_truncateRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_rwr_truncateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rwr_truncateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rwr_truncateRequest_descriptor_; +} + +const xtreemfs_rwr_truncateRequest& xtreemfs_rwr_truncateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_rwr_truncateRequest* xtreemfs_rwr_truncateRequest::default_instance_ = NULL; + +xtreemfs_rwr_truncateRequest* xtreemfs_rwr_truncateRequest::New() const { + return new xtreemfs_rwr_truncateRequest; +} + +void xtreemfs_rwr_truncateRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + new_file_size_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rwr_truncateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_new_file_size; + break; + } + + // required fixed64 new_file_size = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_new_file_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &new_file_size_))); + set_has_new_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rwr_truncateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->new_file_size(), output); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rwr_truncateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->new_file_size(), target); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rwr_truncateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rwr_truncateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rwr_truncateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rwr_truncateRequest::MergeFrom(const xtreemfs_rwr_truncateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_new_file_size()) { + set_new_file_size(from.new_file_size()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rwr_truncateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rwr_truncateRequest::CopyFrom(const xtreemfs_rwr_truncateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rwr_truncateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_rwr_truncateRequest::Swap(xtreemfs_rwr_truncateRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(new_file_size_, other->new_file_size_); + std::swap(object_version_, other->object_version_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rwr_truncateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rwr_truncateRequest_descriptor_; + metadata.reflection = xtreemfs_rwr_truncateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rwr_updateRequest::kFileCredentialsFieldNumber; +const int xtreemfs_rwr_updateRequest::kFileIdFieldNumber; +const int xtreemfs_rwr_updateRequest::kNewFileSizeFieldNumber; +const int xtreemfs_rwr_updateRequest::kObjectNumberFieldNumber; +const int xtreemfs_rwr_updateRequest::kObjectVersionFieldNumber; +const int xtreemfs_rwr_updateRequest::kOffsetFieldNumber; +const int xtreemfs_rwr_updateRequest::kObjFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rwr_updateRequest::xtreemfs_rwr_updateRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rwr_updateRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); + obj_ = const_cast< ::xtreemfs::pbrpc::ObjectData*>(&::xtreemfs::pbrpc::ObjectData::default_instance()); +} + +xtreemfs_rwr_updateRequest::xtreemfs_rwr_updateRequest(const xtreemfs_rwr_updateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rwr_updateRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + new_file_size_ = GOOGLE_ULONGLONG(0); + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + offset_ = 0u; + obj_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rwr_updateRequest::~xtreemfs_rwr_updateRequest() { + SharedDtor(); +} + +void xtreemfs_rwr_updateRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + delete obj_; + } +} + +void xtreemfs_rwr_updateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rwr_updateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rwr_updateRequest_descriptor_; +} + +const xtreemfs_rwr_updateRequest& xtreemfs_rwr_updateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_rwr_updateRequest* xtreemfs_rwr_updateRequest::default_instance_ = NULL; + +xtreemfs_rwr_updateRequest* xtreemfs_rwr_updateRequest::New() const { + return new xtreemfs_rwr_updateRequest; +} + +void xtreemfs_rwr_updateRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + new_file_size_ = GOOGLE_ULONGLONG(0); + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + offset_ = 0u; + if (has_obj()) { + if (obj_ != NULL) obj_->::xtreemfs::pbrpc::ObjectData::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rwr_updateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_new_file_size; + break; + } + + // required fixed64 new_file_size = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_new_file_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &new_file_size_))); + set_has_new_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_offset; + break; + } + + // required fixed32 offset = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &offset_))); + set_has_offset(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_obj; + break; + } + + // required .xtreemfs.pbrpc.ObjectData obj = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_obj: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_obj())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(57)) goto parse_object_number; + break; + } + + // required fixed64 object_number = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_number: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rwr_updateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->new_file_size(), output); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output); + } + + // required fixed32 offset = 5; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->offset(), output); + } + + // required .xtreemfs.pbrpc.ObjectData obj = 6; + if (has_obj()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->obj(), output); + } + + // required fixed64 object_number = 7; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(7, this->object_number(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rwr_updateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->new_file_size(), target); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target); + } + + // required fixed32 offset = 5; + if (has_offset()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->offset(), target); + } + + // required .xtreemfs.pbrpc.ObjectData obj = 6; + if (has_obj()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 6, this->obj(), target); + } + + // required fixed64 object_number = 7; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(7, this->object_number(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rwr_updateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 new_file_size = 3; + if (has_new_file_size()) { + total_size += 1 + 8; + } + + // required fixed64 object_number = 7; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + total_size += 1 + 8; + } + + // required fixed32 offset = 5; + if (has_offset()) { + total_size += 1 + 4; + } + + // required .xtreemfs.pbrpc.ObjectData obj = 6; + if (has_obj()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->obj()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rwr_updateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rwr_updateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rwr_updateRequest::MergeFrom(const xtreemfs_rwr_updateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_new_file_size()) { + set_new_file_size(from.new_file_size()); + } + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + if (from.has_offset()) { + set_offset(from.offset()); + } + if (from.has_obj()) { + mutable_obj()->::xtreemfs::pbrpc::ObjectData::MergeFrom(from.obj()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rwr_updateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rwr_updateRequest::CopyFrom(const xtreemfs_rwr_updateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rwr_updateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000007f) != 0x0000007f) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + if (has_obj()) { + if (!this->obj().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_rwr_updateRequest::Swap(xtreemfs_rwr_updateRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(new_file_size_, other->new_file_size_); + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + std::swap(offset_, other->offset_); + std::swap(obj_, other->obj_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rwr_updateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rwr_updateRequest_descriptor_; + metadata.reflection = xtreemfs_rwr_updateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_internal_get_gmaxRequest::kFileCredentialsFieldNumber; +const int xtreemfs_internal_get_gmaxRequest::kFileIdFieldNumber; +#endif // !_MSC_VER + +xtreemfs_internal_get_gmaxRequest::xtreemfs_internal_get_gmaxRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_internal_get_gmaxRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_internal_get_gmaxRequest::xtreemfs_internal_get_gmaxRequest(const xtreemfs_internal_get_gmaxRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_internal_get_gmaxRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_internal_get_gmaxRequest::~xtreemfs_internal_get_gmaxRequest() { + SharedDtor(); +} + +void xtreemfs_internal_get_gmaxRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_internal_get_gmaxRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_internal_get_gmaxRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_internal_get_gmaxRequest_descriptor_; +} + +const xtreemfs_internal_get_gmaxRequest& xtreemfs_internal_get_gmaxRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_internal_get_gmaxRequest* xtreemfs_internal_get_gmaxRequest::default_instance_ = NULL; + +xtreemfs_internal_get_gmaxRequest* xtreemfs_internal_get_gmaxRequest::New() const { + return new xtreemfs_internal_get_gmaxRequest; +} + +void xtreemfs_internal_get_gmaxRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_internal_get_gmaxRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_internal_get_gmaxRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_internal_get_gmaxRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_internal_get_gmaxRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_internal_get_gmaxRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_internal_get_gmaxRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_internal_get_gmaxRequest::MergeFrom(const xtreemfs_internal_get_gmaxRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_internal_get_gmaxRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_internal_get_gmaxRequest::CopyFrom(const xtreemfs_internal_get_gmaxRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_internal_get_gmaxRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_internal_get_gmaxRequest::Swap(xtreemfs_internal_get_gmaxRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_internal_get_gmaxRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_internal_get_gmaxRequest_descriptor_; + metadata.reflection = xtreemfs_internal_get_gmaxRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_internal_get_file_sizeRequest::kFileCredentialsFieldNumber; +const int xtreemfs_internal_get_file_sizeRequest::kFileIdFieldNumber; +#endif // !_MSC_VER + +xtreemfs_internal_get_file_sizeRequest::xtreemfs_internal_get_file_sizeRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_internal_get_file_sizeRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_internal_get_file_sizeRequest::xtreemfs_internal_get_file_sizeRequest(const xtreemfs_internal_get_file_sizeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_internal_get_file_sizeRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_internal_get_file_sizeRequest::~xtreemfs_internal_get_file_sizeRequest() { + SharedDtor(); +} + +void xtreemfs_internal_get_file_sizeRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_internal_get_file_sizeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_internal_get_file_sizeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_internal_get_file_sizeRequest_descriptor_; +} + +const xtreemfs_internal_get_file_sizeRequest& xtreemfs_internal_get_file_sizeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_internal_get_file_sizeRequest* xtreemfs_internal_get_file_sizeRequest::default_instance_ = NULL; + +xtreemfs_internal_get_file_sizeRequest* xtreemfs_internal_get_file_sizeRequest::New() const { + return new xtreemfs_internal_get_file_sizeRequest; +} + +void xtreemfs_internal_get_file_sizeRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_internal_get_file_sizeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_internal_get_file_sizeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_internal_get_file_sizeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_internal_get_file_sizeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_internal_get_file_sizeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_internal_get_file_sizeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_internal_get_file_sizeRequest::MergeFrom(const xtreemfs_internal_get_file_sizeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_internal_get_file_sizeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_internal_get_file_sizeRequest::CopyFrom(const xtreemfs_internal_get_file_sizeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_internal_get_file_sizeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_internal_get_file_sizeRequest::Swap(xtreemfs_internal_get_file_sizeRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_internal_get_file_sizeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_internal_get_file_sizeRequest_descriptor_; + metadata.reflection = xtreemfs_internal_get_file_sizeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_internal_get_file_sizeResponse::kFileSizeFieldNumber; +#endif // !_MSC_VER + +xtreemfs_internal_get_file_sizeResponse::xtreemfs_internal_get_file_sizeResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_internal_get_file_sizeResponse::InitAsDefaultInstance() { +} + +xtreemfs_internal_get_file_sizeResponse::xtreemfs_internal_get_file_sizeResponse(const xtreemfs_internal_get_file_sizeResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_internal_get_file_sizeResponse::SharedCtor() { + _cached_size_ = 0; + file_size_ = GOOGLE_ULONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_internal_get_file_sizeResponse::~xtreemfs_internal_get_file_sizeResponse() { + SharedDtor(); +} + +void xtreemfs_internal_get_file_sizeResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_internal_get_file_sizeResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_internal_get_file_sizeResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_internal_get_file_sizeResponse_descriptor_; +} + +const xtreemfs_internal_get_file_sizeResponse& xtreemfs_internal_get_file_sizeResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_internal_get_file_sizeResponse* xtreemfs_internal_get_file_sizeResponse::default_instance_ = NULL; + +xtreemfs_internal_get_file_sizeResponse* xtreemfs_internal_get_file_sizeResponse::New() const { + return new xtreemfs_internal_get_file_sizeResponse; +} + +void xtreemfs_internal_get_file_sizeResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + file_size_ = GOOGLE_ULONGLONG(0); + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_internal_get_file_sizeResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required fixed64 file_size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &file_size_))); + set_has_file_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_internal_get_file_sizeResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required fixed64 file_size = 1; + if (has_file_size()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->file_size(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_internal_get_file_sizeResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required fixed64 file_size = 1; + if (has_file_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->file_size(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_internal_get_file_sizeResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required fixed64 file_size = 1; + if (has_file_size()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_internal_get_file_sizeResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_internal_get_file_sizeResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_internal_get_file_sizeResponse::MergeFrom(const xtreemfs_internal_get_file_sizeResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_size()) { + set_file_size(from.file_size()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_internal_get_file_sizeResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_internal_get_file_sizeResponse::CopyFrom(const xtreemfs_internal_get_file_sizeResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_internal_get_file_sizeResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void xtreemfs_internal_get_file_sizeResponse::Swap(xtreemfs_internal_get_file_sizeResponse* other) { + if (other != this) { + std::swap(file_size_, other->file_size_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_internal_get_file_sizeResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_internal_get_file_sizeResponse_descriptor_; + metadata.reflection = xtreemfs_internal_get_file_sizeResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_internal_read_localRequest::kFileCredentialsFieldNumber; +const int xtreemfs_internal_read_localRequest::kFileIdFieldNumber; +const int xtreemfs_internal_read_localRequest::kObjectNumberFieldNumber; +const int xtreemfs_internal_read_localRequest::kObjectVersionFieldNumber; +const int xtreemfs_internal_read_localRequest::kOffsetFieldNumber; +const int xtreemfs_internal_read_localRequest::kLengthFieldNumber; +const int xtreemfs_internal_read_localRequest::kAttachObjectListFieldNumber; +const int xtreemfs_internal_read_localRequest::kRequiredObjectsFieldNumber; +#endif // !_MSC_VER + +xtreemfs_internal_read_localRequest::xtreemfs_internal_read_localRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_internal_read_localRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_internal_read_localRequest::xtreemfs_internal_read_localRequest(const xtreemfs_internal_read_localRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_internal_read_localRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + offset_ = 0u; + length_ = 0u; + attach_object_list_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_internal_read_localRequest::~xtreemfs_internal_read_localRequest() { + SharedDtor(); +} + +void xtreemfs_internal_read_localRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_internal_read_localRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_internal_read_localRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_internal_read_localRequest_descriptor_; +} + +const xtreemfs_internal_read_localRequest& xtreemfs_internal_read_localRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_internal_read_localRequest* xtreemfs_internal_read_localRequest::default_instance_ = NULL; + +xtreemfs_internal_read_localRequest* xtreemfs_internal_read_localRequest::New() const { + return new xtreemfs_internal_read_localRequest; +} + +void xtreemfs_internal_read_localRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + object_number_ = GOOGLE_ULONGLONG(0); + object_version_ = GOOGLE_ULONGLONG(0); + offset_ = 0u; + length_ = 0u; + attach_object_list_ = false; + } + required_objects_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_internal_read_localRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_object_number; + break; + } + + // required fixed64 object_number = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_number: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_number_))); + set_has_object_number(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(33)) goto parse_object_version; + break; + } + + // required fixed64 object_version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_object_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>( + input, &object_version_))); + set_has_object_version(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(45)) goto parse_offset; + break; + } + + // required fixed32 offset = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &offset_))); + set_has_offset(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(53)) goto parse_length; + break; + } + + // required fixed32 length = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &length_))); + set_has_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_attach_object_list; + break; + } + + // required bool attach_object_list = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_attach_object_list: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &attach_object_list_))); + set_has_attach_object_list(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_required_objects; + break; + } + + // repeated .xtreemfs.pbrpc.ObjectList required_objects = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_required_objects: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_required_objects())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_required_objects; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_internal_read_localRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->object_number(), output); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output); + } + + // required fixed32 offset = 5; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->offset(), output); + } + + // required fixed32 length = 6; + if (has_length()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(6, this->length(), output); + } + + // required bool attach_object_list = 7; + if (has_attach_object_list()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->attach_object_list(), output); + } + + // repeated .xtreemfs.pbrpc.ObjectList required_objects = 8; + for (int i = 0; i < this->required_objects_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->required_objects(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_internal_read_localRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->object_number(), target); + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target); + } + + // required fixed32 offset = 5; + if (has_offset()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->offset(), target); + } + + // required fixed32 length = 6; + if (has_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(6, this->length(), target); + } + + // required bool attach_object_list = 7; + if (has_attach_object_list()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->attach_object_list(), target); + } + + // repeated .xtreemfs.pbrpc.ObjectList required_objects = 8; + for (int i = 0; i < this->required_objects_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 8, this->required_objects(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_internal_read_localRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed64 object_number = 3; + if (has_object_number()) { + total_size += 1 + 8; + } + + // required fixed64 object_version = 4; + if (has_object_version()) { + total_size += 1 + 8; + } + + // required fixed32 offset = 5; + if (has_offset()) { + total_size += 1 + 4; + } + + // required fixed32 length = 6; + if (has_length()) { + total_size += 1 + 4; + } + + // required bool attach_object_list = 7; + if (has_attach_object_list()) { + total_size += 1 + 1; + } + + } + // repeated .xtreemfs.pbrpc.ObjectList required_objects = 8; + total_size += 1 * this->required_objects_size(); + for (int i = 0; i < this->required_objects_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->required_objects(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_internal_read_localRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_internal_read_localRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_internal_read_localRequest::MergeFrom(const xtreemfs_internal_read_localRequest& from) { + GOOGLE_CHECK_NE(&from, this); + required_objects_.MergeFrom(from.required_objects_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_object_number()) { + set_object_number(from.object_number()); + } + if (from.has_object_version()) { + set_object_version(from.object_version()); + } + if (from.has_offset()) { + set_offset(from.offset()); + } + if (from.has_length()) { + set_length(from.length()); + } + if (from.has_attach_object_list()) { + set_attach_object_list(from.attach_object_list()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_internal_read_localRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_internal_read_localRequest::CopyFrom(const xtreemfs_internal_read_localRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_internal_read_localRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x0000007f) != 0x0000007f) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + for (int i = 0; i < required_objects_size(); i++) { + if (!this->required_objects(i).IsInitialized()) return false; + } + return true; +} + +void xtreemfs_internal_read_localRequest::Swap(xtreemfs_internal_read_localRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(object_number_, other->object_number_); + std::swap(object_version_, other->object_version_); + std::swap(offset_, other->offset_); + std::swap(length_, other->length_); + std::swap(attach_object_list_, other->attach_object_list_); + required_objects_.Swap(&other->required_objects_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_internal_read_localRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_internal_read_localRequest_descriptor_; + metadata.reflection = xtreemfs_internal_read_localRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_internal_get_object_setRequest::kFileCredentialsFieldNumber; +const int xtreemfs_internal_get_object_setRequest::kFileIdFieldNumber; +#endif // !_MSC_VER + +xtreemfs_internal_get_object_setRequest::xtreemfs_internal_get_object_setRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_internal_get_object_setRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_internal_get_object_setRequest::xtreemfs_internal_get_object_setRequest(const xtreemfs_internal_get_object_setRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_internal_get_object_setRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_internal_get_object_setRequest::~xtreemfs_internal_get_object_setRequest() { + SharedDtor(); +} + +void xtreemfs_internal_get_object_setRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_internal_get_object_setRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_internal_get_object_setRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_internal_get_object_setRequest_descriptor_; +} + +const xtreemfs_internal_get_object_setRequest& xtreemfs_internal_get_object_setRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_internal_get_object_setRequest* xtreemfs_internal_get_object_setRequest::default_instance_ = NULL; + +xtreemfs_internal_get_object_setRequest* xtreemfs_internal_get_object_setRequest::New() const { + return new xtreemfs_internal_get_object_setRequest; +} + +void xtreemfs_internal_get_object_setRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_internal_get_object_setRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_internal_get_object_setRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_internal_get_object_setRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_internal_get_object_setRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_internal_get_object_setRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_internal_get_object_setRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_internal_get_object_setRequest::MergeFrom(const xtreemfs_internal_get_object_setRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_internal_get_object_setRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_internal_get_object_setRequest::CopyFrom(const xtreemfs_internal_get_object_setRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_internal_get_object_setRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_internal_get_object_setRequest::Swap(xtreemfs_internal_get_object_setRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_internal_get_object_setRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_internal_get_object_setRequest_descriptor_; + metadata.reflection = xtreemfs_internal_get_object_setRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_internal_get_fileid_listResponse::kFileIdsFieldNumber; +#endif // !_MSC_VER + +xtreemfs_internal_get_fileid_listResponse::xtreemfs_internal_get_fileid_listResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_internal_get_fileid_listResponse::InitAsDefaultInstance() { +} + +xtreemfs_internal_get_fileid_listResponse::xtreemfs_internal_get_fileid_listResponse(const xtreemfs_internal_get_fileid_listResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_internal_get_fileid_listResponse::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_internal_get_fileid_listResponse::~xtreemfs_internal_get_fileid_listResponse() { + SharedDtor(); +} + +void xtreemfs_internal_get_fileid_listResponse::SharedDtor() { + if (this != default_instance_) { + } +} + +void xtreemfs_internal_get_fileid_listResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_internal_get_fileid_listResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_internal_get_fileid_listResponse_descriptor_; +} + +const xtreemfs_internal_get_fileid_listResponse& xtreemfs_internal_get_fileid_listResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_internal_get_fileid_listResponse* xtreemfs_internal_get_fileid_listResponse::default_instance_ = NULL; + +xtreemfs_internal_get_fileid_listResponse* xtreemfs_internal_get_fileid_listResponse::New() const { + return new xtreemfs_internal_get_fileid_listResponse; +} + +void xtreemfs_internal_get_fileid_listResponse::Clear() { + file_ids_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_internal_get_fileid_listResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string file_ids = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_ids: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_file_ids())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_ids(this->file_ids_size() - 1).data(), + this->file_ids(this->file_ids_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_file_ids; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_internal_get_fileid_listResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated string file_ids = 1; + for (int i = 0; i < this->file_ids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_ids(i).data(), this->file_ids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->file_ids(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_internal_get_fileid_listResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated string file_ids = 1; + for (int i = 0; i < this->file_ids_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_ids(i).data(), this->file_ids(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1, this->file_ids(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_internal_get_fileid_listResponse::ByteSize() const { + int total_size = 0; + + // repeated string file_ids = 1; + total_size += 1 * this->file_ids_size(); + for (int i = 0; i < this->file_ids_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_ids(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_internal_get_fileid_listResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_internal_get_fileid_listResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_internal_get_fileid_listResponse::MergeFrom(const xtreemfs_internal_get_fileid_listResponse& from) { + GOOGLE_CHECK_NE(&from, this); + file_ids_.MergeFrom(from.file_ids_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_internal_get_fileid_listResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_internal_get_fileid_listResponse::CopyFrom(const xtreemfs_internal_get_fileid_listResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_internal_get_fileid_listResponse::IsInitialized() const { + + return true; +} + +void xtreemfs_internal_get_fileid_listResponse::Swap(xtreemfs_internal_get_fileid_listResponse* other) { + if (other != this) { + file_ids_.Swap(&other->file_ids_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_internal_get_fileid_listResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_internal_get_fileid_listResponse_descriptor_; + metadata.reflection = xtreemfs_internal_get_fileid_listResponse_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int lockRequest::kFileCredentialsFieldNumber; +const int lockRequest::kLockRequestFieldNumber; +#endif // !_MSC_VER + +lockRequest::lockRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void lockRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); + lock_request_ = const_cast< ::xtreemfs::pbrpc::Lock*>(&::xtreemfs::pbrpc::Lock::default_instance()); +} + +lockRequest::lockRequest(const lockRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void lockRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + lock_request_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +lockRequest::~lockRequest() { + SharedDtor(); +} + +void lockRequest::SharedDtor() { + if (this != default_instance_) { + delete file_credentials_; + delete lock_request_; + } +} + +void lockRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* lockRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return lockRequest_descriptor_; +} + +const lockRequest& lockRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +lockRequest* lockRequest::default_instance_ = NULL; + +lockRequest* lockRequest::New() const { + return new lockRequest; +} + +void lockRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_lock_request()) { + if (lock_request_ != NULL) lock_request_->::xtreemfs::pbrpc::Lock::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool lockRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_lock_request; + break; + } + + // required .xtreemfs.pbrpc.Lock lock_request = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_lock_request: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_lock_request())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void lockRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required .xtreemfs.pbrpc.Lock lock_request = 2; + if (has_lock_request()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->lock_request(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* lockRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required .xtreemfs.pbrpc.Lock lock_request = 2; + if (has_lock_request()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->lock_request(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int lockRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required .xtreemfs.pbrpc.Lock lock_request = 2; + if (has_lock_request()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->lock_request()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void lockRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const lockRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void lockRequest::MergeFrom(const lockRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_lock_request()) { + mutable_lock_request()->::xtreemfs::pbrpc::Lock::MergeFrom(from.lock_request()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void lockRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void lockRequest::CopyFrom(const lockRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool lockRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + if (has_lock_request()) { + if (!this->lock_request().IsInitialized()) return false; + } + return true; +} + +void lockRequest::Swap(lockRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(lock_request_, other->lock_request_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata lockRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = lockRequest_descriptor_; + metadata.reflection = lockRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_pingMesssage::kCoordinatesFieldNumber; +const int xtreemfs_pingMesssage::kRequestResponseFieldNumber; +#endif // !_MSC_VER + +xtreemfs_pingMesssage::xtreemfs_pingMesssage() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_pingMesssage::InitAsDefaultInstance() { + coordinates_ = const_cast< ::xtreemfs::pbrpc::VivaldiCoordinates*>(&::xtreemfs::pbrpc::VivaldiCoordinates::default_instance()); +} + +xtreemfs_pingMesssage::xtreemfs_pingMesssage(const xtreemfs_pingMesssage& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_pingMesssage::SharedCtor() { + _cached_size_ = 0; + coordinates_ = NULL; + request_response_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_pingMesssage::~xtreemfs_pingMesssage() { + SharedDtor(); +} + +void xtreemfs_pingMesssage::SharedDtor() { + if (this != default_instance_) { + delete coordinates_; + } +} + +void xtreemfs_pingMesssage::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_pingMesssage::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_pingMesssage_descriptor_; +} + +const xtreemfs_pingMesssage& xtreemfs_pingMesssage::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_pingMesssage* xtreemfs_pingMesssage::default_instance_ = NULL; + +xtreemfs_pingMesssage* xtreemfs_pingMesssage::New() const { + return new xtreemfs_pingMesssage; +} + +void xtreemfs_pingMesssage::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_coordinates()) { + if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear(); + } + request_response_ = false; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_pingMesssage::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_coordinates())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_request_response; + break; + } + + // required bool request_response = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_request_response: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &request_response_))); + set_has_request_response(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_pingMesssage::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 1; + if (has_coordinates()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->coordinates(), output); + } + + // required bool request_response = 2; + if (has_request_response()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->request_response(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_pingMesssage::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 1; + if (has_coordinates()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->coordinates(), target); + } + + // required bool request_response = 2; + if (has_request_response()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->request_response(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_pingMesssage::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 1; + if (has_coordinates()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->coordinates()); + } + + // required bool request_response = 2; + if (has_request_response()) { + total_size += 1 + 1; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_pingMesssage::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_pingMesssage* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_pingMesssage::MergeFrom(const xtreemfs_pingMesssage& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_coordinates()) { + mutable_coordinates()->::xtreemfs::pbrpc::VivaldiCoordinates::MergeFrom(from.coordinates()); + } + if (from.has_request_response()) { + set_request_response(from.request_response()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_pingMesssage::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_pingMesssage::CopyFrom(const xtreemfs_pingMesssage& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_pingMesssage::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_coordinates()) { + if (!this->coordinates().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_pingMesssage::Swap(xtreemfs_pingMesssage* other) { + if (other != this) { + std::swap(coordinates_, other->coordinates_); + std::swap(request_response_, other->request_response_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_pingMesssage::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_pingMesssage_descriptor_; + metadata.reflection = xtreemfs_pingMesssage_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rwr_auth_stateRequest::kFileCredentialsFieldNumber; +const int xtreemfs_rwr_auth_stateRequest::kFileIdFieldNumber; +const int xtreemfs_rwr_auth_stateRequest::kStateFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rwr_auth_stateRequest::xtreemfs_rwr_auth_stateRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rwr_auth_stateRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); + state_ = const_cast< ::xtreemfs::pbrpc::AuthoritativeReplicaState*>(&::xtreemfs::pbrpc::AuthoritativeReplicaState::default_instance()); +} + +xtreemfs_rwr_auth_stateRequest::xtreemfs_rwr_auth_stateRequest(const xtreemfs_rwr_auth_stateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rwr_auth_stateRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + state_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rwr_auth_stateRequest::~xtreemfs_rwr_auth_stateRequest() { + SharedDtor(); +} + +void xtreemfs_rwr_auth_stateRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + delete state_; + } +} + +void xtreemfs_rwr_auth_stateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rwr_auth_stateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rwr_auth_stateRequest_descriptor_; +} + +const xtreemfs_rwr_auth_stateRequest& xtreemfs_rwr_auth_stateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_rwr_auth_stateRequest* xtreemfs_rwr_auth_stateRequest::default_instance_ = NULL; + +xtreemfs_rwr_auth_stateRequest* xtreemfs_rwr_auth_stateRequest::New() const { + return new xtreemfs_rwr_auth_stateRequest; +} + +void xtreemfs_rwr_auth_stateRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + if (has_state()) { + if (state_ != NULL) state_->::xtreemfs::pbrpc::AuthoritativeReplicaState::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rwr_auth_stateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_state; + break; + } + + // required .xtreemfs.pbrpc.AuthoritativeReplicaState state = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_state: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_state())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rwr_auth_stateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required .xtreemfs.pbrpc.AuthoritativeReplicaState state = 3; + if (has_state()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->state(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rwr_auth_stateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required .xtreemfs.pbrpc.AuthoritativeReplicaState state = 3; + if (has_state()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->state(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rwr_auth_stateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required .xtreemfs.pbrpc.AuthoritativeReplicaState state = 3; + if (has_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->state()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rwr_auth_stateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rwr_auth_stateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rwr_auth_stateRequest::MergeFrom(const xtreemfs_rwr_auth_stateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_state()) { + mutable_state()->::xtreemfs::pbrpc::AuthoritativeReplicaState::MergeFrom(from.state()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rwr_auth_stateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rwr_auth_stateRequest::CopyFrom(const xtreemfs_rwr_auth_stateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rwr_auth_stateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + if (has_state()) { + if (!this->state().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_rwr_auth_stateRequest::Swap(xtreemfs_rwr_auth_stateRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(state_, other->state_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rwr_auth_stateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rwr_auth_stateRequest_descriptor_; + metadata.reflection = xtreemfs_rwr_auth_stateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_rwr_reset_completeRequest::kFileCredentialsFieldNumber; +const int xtreemfs_rwr_reset_completeRequest::kFileIdFieldNumber; +const int xtreemfs_rwr_reset_completeRequest::kPrimaryEpochFieldNumber; +#endif // !_MSC_VER + +xtreemfs_rwr_reset_completeRequest::xtreemfs_rwr_reset_completeRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_rwr_reset_completeRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_rwr_reset_completeRequest::xtreemfs_rwr_reset_completeRequest(const xtreemfs_rwr_reset_completeRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_rwr_reset_completeRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + primary_epoch_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_rwr_reset_completeRequest::~xtreemfs_rwr_reset_completeRequest() { + SharedDtor(); +} + +void xtreemfs_rwr_reset_completeRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_rwr_reset_completeRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_rwr_reset_completeRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_rwr_reset_completeRequest_descriptor_; +} + +const xtreemfs_rwr_reset_completeRequest& xtreemfs_rwr_reset_completeRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_rwr_reset_completeRequest* xtreemfs_rwr_reset_completeRequest::default_instance_ = NULL; + +xtreemfs_rwr_reset_completeRequest* xtreemfs_rwr_reset_completeRequest::New() const { + return new xtreemfs_rwr_reset_completeRequest; +} + +void xtreemfs_rwr_reset_completeRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + primary_epoch_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_rwr_reset_completeRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(29)) goto parse_primary_epoch; + break; + } + + // required fixed32 primary_epoch = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) { + parse_primary_epoch: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>( + input, &primary_epoch_))); + set_has_primary_epoch(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_rwr_reset_completeRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + // required fixed32 primary_epoch = 3; + if (has_primary_epoch()) { + ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->primary_epoch(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_rwr_reset_completeRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + // required fixed32 primary_epoch = 3; + if (has_primary_epoch()) { + target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->primary_epoch(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_rwr_reset_completeRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + // required fixed32 primary_epoch = 3; + if (has_primary_epoch()) { + total_size += 1 + 4; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_rwr_reset_completeRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_rwr_reset_completeRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_rwr_reset_completeRequest::MergeFrom(const xtreemfs_rwr_reset_completeRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + if (from.has_primary_epoch()) { + set_primary_epoch(from.primary_epoch()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_rwr_reset_completeRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_rwr_reset_completeRequest::CopyFrom(const xtreemfs_rwr_reset_completeRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_rwr_reset_completeRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_rwr_reset_completeRequest::Swap(xtreemfs_rwr_reset_completeRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(primary_epoch_, other->primary_epoch_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_rwr_reset_completeRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_rwr_reset_completeRequest_descriptor_; + metadata.reflection = xtreemfs_rwr_reset_completeRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_xloc_set_invalidateRequest::kFileCredentialsFieldNumber; +const int xtreemfs_xloc_set_invalidateRequest::kFileIdFieldNumber; +#endif // !_MSC_VER + +xtreemfs_xloc_set_invalidateRequest::xtreemfs_xloc_set_invalidateRequest() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_xloc_set_invalidateRequest::InitAsDefaultInstance() { + file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance()); +} + +xtreemfs_xloc_set_invalidateRequest::xtreemfs_xloc_set_invalidateRequest(const xtreemfs_xloc_set_invalidateRequest& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_xloc_set_invalidateRequest::SharedCtor() { + _cached_size_ = 0; + file_credentials_ = NULL; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_xloc_set_invalidateRequest::~xtreemfs_xloc_set_invalidateRequest() { + SharedDtor(); +} + +void xtreemfs_xloc_set_invalidateRequest::SharedDtor() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (this != default_instance_) { + delete file_credentials_; + } +} + +void xtreemfs_xloc_set_invalidateRequest::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_xloc_set_invalidateRequest::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_xloc_set_invalidateRequest_descriptor_; +} + +const xtreemfs_xloc_set_invalidateRequest& xtreemfs_xloc_set_invalidateRequest::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_xloc_set_invalidateRequest* xtreemfs_xloc_set_invalidateRequest::default_instance_ = NULL; + +xtreemfs_xloc_set_invalidateRequest* xtreemfs_xloc_set_invalidateRequest::New() const { + return new xtreemfs_xloc_set_invalidateRequest; +} + +void xtreemfs_xloc_set_invalidateRequest::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_file_credentials()) { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + } + if (has_file_id()) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_xloc_set_invalidateRequest::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_file_credentials())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_file_id; + break; + } + + // required string file_id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_file_id: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_file_id())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_xloc_set_invalidateRequest::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->file_credentials(), output); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->file_id(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_xloc_set_invalidateRequest::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->file_credentials(), target); + } + + // required string file_id = 2; + if (has_file_id()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->file_id().data(), this->file_id().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->file_id(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_xloc_set_invalidateRequest::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + if (has_file_credentials()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->file_credentials()); + } + + // required string file_id = 2; + if (has_file_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->file_id()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_xloc_set_invalidateRequest::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_xloc_set_invalidateRequest* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_xloc_set_invalidateRequest::MergeFrom(const xtreemfs_xloc_set_invalidateRequest& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_file_credentials()) { + mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials()); + } + if (from.has_file_id()) { + set_file_id(from.file_id()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_xloc_set_invalidateRequest::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_xloc_set_invalidateRequest::CopyFrom(const xtreemfs_xloc_set_invalidateRequest& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_xloc_set_invalidateRequest::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_file_credentials()) { + if (!this->file_credentials().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_xloc_set_invalidateRequest::Swap(xtreemfs_xloc_set_invalidateRequest* other) { + if (other != this) { + std::swap(file_credentials_, other->file_credentials_); + std::swap(file_id_, other->file_id_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_xloc_set_invalidateRequest::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_xloc_set_invalidateRequest_descriptor_; + metadata.reflection = xtreemfs_xloc_set_invalidateRequest_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int xtreemfs_xloc_set_invalidateResponse::kLeaseStateFieldNumber; +const int xtreemfs_xloc_set_invalidateResponse::kReplicaStatusFieldNumber; +#endif // !_MSC_VER + +xtreemfs_xloc_set_invalidateResponse::xtreemfs_xloc_set_invalidateResponse() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void xtreemfs_xloc_set_invalidateResponse::InitAsDefaultInstance() { + replica_status_ = const_cast< ::xtreemfs::pbrpc::ReplicaStatus*>(&::xtreemfs::pbrpc::ReplicaStatus::default_instance()); +} + +xtreemfs_xloc_set_invalidateResponse::xtreemfs_xloc_set_invalidateResponse(const xtreemfs_xloc_set_invalidateResponse& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void xtreemfs_xloc_set_invalidateResponse::SharedCtor() { + _cached_size_ = 0; + lease_state_ = 0; + replica_status_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +xtreemfs_xloc_set_invalidateResponse::~xtreemfs_xloc_set_invalidateResponse() { + SharedDtor(); +} + +void xtreemfs_xloc_set_invalidateResponse::SharedDtor() { + if (this != default_instance_) { + delete replica_status_; + } +} + +void xtreemfs_xloc_set_invalidateResponse::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* xtreemfs_xloc_set_invalidateResponse::descriptor() { + protobuf_AssignDescriptorsOnce(); + return xtreemfs_xloc_set_invalidateResponse_descriptor_; +} + +const xtreemfs_xloc_set_invalidateResponse& xtreemfs_xloc_set_invalidateResponse::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + return *default_instance_; +} + +xtreemfs_xloc_set_invalidateResponse* xtreemfs_xloc_set_invalidateResponse::default_instance_ = NULL; + +xtreemfs_xloc_set_invalidateResponse* xtreemfs_xloc_set_invalidateResponse::New() const { + return new xtreemfs_xloc_set_invalidateResponse; +} + +void xtreemfs_xloc_set_invalidateResponse::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + lease_state_ = 0; + if (has_replica_status()) { + if (replica_status_ != NULL) replica_status_->::xtreemfs::pbrpc::ReplicaStatus::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool xtreemfs_xloc_set_invalidateResponse::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .xtreemfs.pbrpc.LeaseState lease_state = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::xtreemfs::pbrpc::LeaseState_IsValid(value)) { + set_lease_state(static_cast< ::xtreemfs::pbrpc::LeaseState >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_replica_status; + break; + } + + // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_replica_status: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_replica_status())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void xtreemfs_xloc_set_invalidateResponse::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .xtreemfs.pbrpc.LeaseState lease_state = 1; + if (has_lease_state()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->lease_state(), output); + } + + // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2; + if (has_replica_status()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->replica_status(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* xtreemfs_xloc_set_invalidateResponse::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .xtreemfs.pbrpc.LeaseState lease_state = 1; + if (has_lease_state()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->lease_state(), target); + } + + // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2; + if (has_replica_status()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->replica_status(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int xtreemfs_xloc_set_invalidateResponse::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .xtreemfs.pbrpc.LeaseState lease_state = 1; + if (has_lease_state()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->lease_state()); + } + + // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2; + if (has_replica_status()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->replica_status()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void xtreemfs_xloc_set_invalidateResponse::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const xtreemfs_xloc_set_invalidateResponse* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void xtreemfs_xloc_set_invalidateResponse::MergeFrom(const xtreemfs_xloc_set_invalidateResponse& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_lease_state()) { + set_lease_state(from.lease_state()); + } + if (from.has_replica_status()) { + mutable_replica_status()->::xtreemfs::pbrpc::ReplicaStatus::MergeFrom(from.replica_status()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void xtreemfs_xloc_set_invalidateResponse::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void xtreemfs_xloc_set_invalidateResponse::CopyFrom(const xtreemfs_xloc_set_invalidateResponse& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool xtreemfs_xloc_set_invalidateResponse::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_replica_status()) { + if (!this->replica_status().IsInitialized()) return false; + } + return true; +} + +void xtreemfs_xloc_set_invalidateResponse::Swap(xtreemfs_xloc_set_invalidateResponse* other) { + if (other != this) { + std::swap(lease_state_, other->lease_state_); + std::swap(replica_status_, other->replica_status_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata xtreemfs_xloc_set_invalidateResponse::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = xtreemfs_xloc_set_invalidateResponse_descriptor_; + metadata.reflection = xtreemfs_xloc_set_invalidateResponse_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +// @@protoc_insertion_point(global_scope) diff --git a/cpp/generated/xtreemfs/OSD.pb.h b/cpp/generated/xtreemfs/OSD.pb.h new file mode 100644 index 0000000..f299263 --- /dev/null +++ b/cpp/generated/xtreemfs/OSD.pb.h @@ -0,0 +1,9181 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: xtreemfs/OSD.proto + +#ifndef PROTOBUF_xtreemfs_2fOSD_2eproto__INCLUDED +#define PROTOBUF_xtreemfs_2fOSD_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2005000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include "include/PBRPC.pb.h" +#include "include/Common.pb.h" +#include "xtreemfs/GlobalTypes.pb.h" +// @@protoc_insertion_point(includes) + +namespace xtreemfs { +namespace pbrpc { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); +void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); +void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + +class InternalGmax; +class Lock; +class ObjectData; +class ObjectList; +class ObjectVersion; +class TruncateRecord; +class TruncateLog; +class XLocSetVersionState; +class ReplicaStatus; +class ObjectVersionMapping; +class AuthoritativeReplicaState; +class InternalReadLocalResponse; +class readRequest; +class truncateRequest; +class unlink_osd_Request; +class writeRequest; +class xtreemfs_broadcast_gmaxRequest; +class xtreemfs_check_objectRequest; +class xtreemfs_cleanup_get_resultsResponse; +class xtreemfs_cleanup_is_runningResponse; +class xtreemfs_cleanup_startRequest; +class xtreemfs_cleanup_statusResponse; +class xtreemfs_rwr_fetchRequest; +class xtreemfs_repair_objectRequest; +class xtreemfs_rwr_flease_msgRequest; +class xtreemfs_rwr_set_primary_epochRequest; +class xtreemfs_rwr_statusRequest; +class xtreemfs_rwr_truncateRequest; +class xtreemfs_rwr_updateRequest; +class xtreemfs_internal_get_gmaxRequest; +class xtreemfs_internal_get_file_sizeRequest; +class xtreemfs_internal_get_file_sizeResponse; +class xtreemfs_internal_read_localRequest; +class xtreemfs_internal_get_object_setRequest; +class xtreemfs_internal_get_fileid_listResponse; +class lockRequest; +class xtreemfs_pingMesssage; +class xtreemfs_rwr_auth_stateRequest; +class xtreemfs_rwr_reset_completeRequest; +class xtreemfs_xloc_set_invalidateRequest; +class xtreemfs_xloc_set_invalidateResponse; + +enum OSDHealthResult { + OSD_HEALTH_RESULT_PASSED = 0, + OSD_HEALTH_RESULT_WARNING = 1, + OSD_HEALTH_RESULT_FAILED = 2, + OSD_HEALTH_RESULT_NOT_AVAIL = 3 +}; +bool OSDHealthResult_IsValid(int value); +const OSDHealthResult OSDHealthResult_MIN = OSD_HEALTH_RESULT_PASSED; +const OSDHealthResult OSDHealthResult_MAX = OSD_HEALTH_RESULT_NOT_AVAIL; +const int OSDHealthResult_ARRAYSIZE = OSDHealthResult_MAX + 1; + +const ::google::protobuf::EnumDescriptor* OSDHealthResult_descriptor(); +inline const ::std::string& OSDHealthResult_Name(OSDHealthResult value) { + return ::google::protobuf::internal::NameOfEnum( + OSDHealthResult_descriptor(), value); +} +inline bool OSDHealthResult_Parse( + const ::std::string& name, OSDHealthResult* value) { + return ::google::protobuf::internal::ParseNamedEnum( + OSDHealthResult_descriptor(), name, value); +} +// =================================================================== + +class InternalGmax : public ::google::protobuf::Message { + public: + InternalGmax(); + virtual ~InternalGmax(); + + InternalGmax(const InternalGmax& from); + + inline InternalGmax& operator=(const InternalGmax& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InternalGmax& default_instance(); + + void Swap(InternalGmax* other); + + // implements Message ---------------------------------------------- + + InternalGmax* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InternalGmax& from); + void MergeFrom(const InternalGmax& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 epoch = 1; + inline bool has_epoch() const; + inline void clear_epoch(); + static const int kEpochFieldNumber = 1; + inline ::google::protobuf::uint64 epoch() const; + inline void set_epoch(::google::protobuf::uint64 value); + + // required fixed64 file_size = 2; + inline bool has_file_size() const; + inline void clear_file_size(); + static const int kFileSizeFieldNumber = 2; + inline ::google::protobuf::uint64 file_size() const; + inline void set_file_size(::google::protobuf::uint64 value); + + // required fixed64 last_object_id = 3; + inline bool has_last_object_id() const; + inline void clear_last_object_id(); + static const int kLastObjectIdFieldNumber = 3; + inline ::google::protobuf::uint64 last_object_id() const; + inline void set_last_object_id(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.InternalGmax) + private: + inline void set_has_epoch(); + inline void clear_has_epoch(); + inline void set_has_file_size(); + inline void clear_has_file_size(); + inline void set_has_last_object_id(); + inline void clear_has_last_object_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 epoch_; + ::google::protobuf::uint64 file_size_; + ::google::protobuf::uint64 last_object_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static InternalGmax* default_instance_; +}; +// ------------------------------------------------------------------- + +class Lock : public ::google::protobuf::Message { + public: + Lock(); + virtual ~Lock(); + + Lock(const Lock& from); + + inline Lock& operator=(const Lock& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Lock& default_instance(); + + void Swap(Lock* other); + + // implements Message ---------------------------------------------- + + Lock* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Lock& from); + void MergeFrom(const Lock& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 client_pid = 1; + inline bool has_client_pid() const; + inline void clear_client_pid(); + static const int kClientPidFieldNumber = 1; + inline ::google::protobuf::uint32 client_pid() const; + inline void set_client_pid(::google::protobuf::uint32 value); + + // required string client_uuid = 2; + inline bool has_client_uuid() const; + inline void clear_client_uuid(); + static const int kClientUuidFieldNumber = 2; + inline const ::std::string& client_uuid() const; + inline void set_client_uuid(const ::std::string& value); + inline void set_client_uuid(const char* value); + inline void set_client_uuid(const char* value, size_t size); + inline ::std::string* mutable_client_uuid(); + inline ::std::string* release_client_uuid(); + inline void set_allocated_client_uuid(::std::string* client_uuid); + + // required fixed64 length = 3; + inline bool has_length() const; + inline void clear_length(); + static const int kLengthFieldNumber = 3; + inline ::google::protobuf::uint64 length() const; + inline void set_length(::google::protobuf::uint64 value); + + // required fixed64 offset = 4; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 4; + inline ::google::protobuf::uint64 offset() const; + inline void set_offset(::google::protobuf::uint64 value); + + // required bool exclusive = 5; + inline bool has_exclusive() const; + inline void clear_exclusive(); + static const int kExclusiveFieldNumber = 5; + inline bool exclusive() const; + inline void set_exclusive(bool value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Lock) + private: + inline void set_has_client_pid(); + inline void clear_has_client_pid(); + inline void set_has_client_uuid(); + inline void clear_has_client_uuid(); + inline void set_has_length(); + inline void clear_has_length(); + inline void set_has_offset(); + inline void clear_has_offset(); + inline void set_has_exclusive(); + inline void clear_has_exclusive(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* client_uuid_; + ::google::protobuf::uint64 length_; + ::google::protobuf::uint32 client_pid_; + bool exclusive_; + ::google::protobuf::uint64 offset_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static Lock* default_instance_; +}; +// ------------------------------------------------------------------- + +class ObjectData : public ::google::protobuf::Message { + public: + ObjectData(); + virtual ~ObjectData(); + + ObjectData(const ObjectData& from); + + inline ObjectData& operator=(const ObjectData& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ObjectData& default_instance(); + + void Swap(ObjectData* other); + + // implements Message ---------------------------------------------- + + ObjectData* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ObjectData& from); + void MergeFrom(const ObjectData& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 checksum = 1; + inline bool has_checksum() const; + inline void clear_checksum(); + static const int kChecksumFieldNumber = 1; + inline ::google::protobuf::uint32 checksum() const; + inline void set_checksum(::google::protobuf::uint32 value); + + // required bool invalid_checksum_on_osd = 2; + inline bool has_invalid_checksum_on_osd() const; + inline void clear_invalid_checksum_on_osd(); + static const int kInvalidChecksumOnOsdFieldNumber = 2; + inline bool invalid_checksum_on_osd() const; + inline void set_invalid_checksum_on_osd(bool value); + + // required fixed32 zero_padding = 3; + inline bool has_zero_padding() const; + inline void clear_zero_padding(); + static const int kZeroPaddingFieldNumber = 3; + inline ::google::protobuf::uint32 zero_padding() const; + inline void set_zero_padding(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ObjectData) + private: + inline void set_has_checksum(); + inline void clear_has_checksum(); + inline void set_has_invalid_checksum_on_osd(); + inline void clear_has_invalid_checksum_on_osd(); + inline void set_has_zero_padding(); + inline void clear_has_zero_padding(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 checksum_; + bool invalid_checksum_on_osd_; + ::google::protobuf::uint32 zero_padding_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static ObjectData* default_instance_; +}; +// ------------------------------------------------------------------- + +class ObjectList : public ::google::protobuf::Message { + public: + ObjectList(); + virtual ~ObjectList(); + + ObjectList(const ObjectList& from); + + inline ObjectList& operator=(const ObjectList& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ObjectList& default_instance(); + + void Swap(ObjectList* other); + + // implements Message ---------------------------------------------- + + ObjectList* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ObjectList& from); + void MergeFrom(const ObjectList& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required bytes set = 1; + inline bool has_set() const; + inline void clear_set(); + static const int kSetFieldNumber = 1; + inline const ::std::string& set() const; + inline void set_set(const ::std::string& value); + inline void set_set(const char* value); + inline void set_set(const void* value, size_t size); + inline ::std::string* mutable_set(); + inline ::std::string* release_set(); + inline void set_allocated_set(::std::string* set); + + // required fixed32 stripe_width = 2; + inline bool has_stripe_width() const; + inline void clear_stripe_width(); + static const int kStripeWidthFieldNumber = 2; + inline ::google::protobuf::uint32 stripe_width() const; + inline void set_stripe_width(::google::protobuf::uint32 value); + + // required fixed32 first_ = 3; + inline bool has_first_() const; + inline void clear_first_(); + static const int kFirstFieldNumber = 3; + inline ::google::protobuf::uint32 first_() const; + inline void set_first_(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ObjectList) + private: + inline void set_has_set(); + inline void clear_has_set(); + inline void set_has_stripe_width(); + inline void clear_has_stripe_width(); + inline void set_has_first_(); + inline void clear_has_first_(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* set_; + ::google::protobuf::uint32 stripe_width_; + ::google::protobuf::uint32 first__; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static ObjectList* default_instance_; +}; +// ------------------------------------------------------------------- + +class ObjectVersion : public ::google::protobuf::Message { + public: + ObjectVersion(); + virtual ~ObjectVersion(); + + ObjectVersion(const ObjectVersion& from); + + inline ObjectVersion& operator=(const ObjectVersion& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ObjectVersion& default_instance(); + + void Swap(ObjectVersion* other); + + // implements Message ---------------------------------------------- + + ObjectVersion* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ObjectVersion& from); + void MergeFrom(const ObjectVersion& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 object_number = 1; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 1; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 2; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 2; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ObjectVersion) + private: + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static ObjectVersion* default_instance_; +}; +// ------------------------------------------------------------------- + +class TruncateRecord : public ::google::protobuf::Message { + public: + TruncateRecord(); + virtual ~TruncateRecord(); + + TruncateRecord(const TruncateRecord& from); + + inline TruncateRecord& operator=(const TruncateRecord& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const TruncateRecord& default_instance(); + + void Swap(TruncateRecord* other); + + // implements Message ---------------------------------------------- + + TruncateRecord* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const TruncateRecord& from); + void MergeFrom(const TruncateRecord& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 version = 1; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 1; + inline ::google::protobuf::uint64 version() const; + inline void set_version(::google::protobuf::uint64 value); + + // required fixed64 last_object_number = 2; + inline bool has_last_object_number() const; + inline void clear_last_object_number(); + static const int kLastObjectNumberFieldNumber = 2; + inline ::google::protobuf::uint64 last_object_number() const; + inline void set_last_object_number(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.TruncateRecord) + private: + inline void set_has_version(); + inline void clear_has_version(); + inline void set_has_last_object_number(); + inline void clear_has_last_object_number(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 version_; + ::google::protobuf::uint64 last_object_number_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static TruncateRecord* default_instance_; +}; +// ------------------------------------------------------------------- + +class TruncateLog : public ::google::protobuf::Message { + public: + TruncateLog(); + virtual ~TruncateLog(); + + TruncateLog(const TruncateLog& from); + + inline TruncateLog& operator=(const TruncateLog& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const TruncateLog& default_instance(); + + void Swap(TruncateLog* other); + + // implements Message ---------------------------------------------- + + TruncateLog* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const TruncateLog& from); + void MergeFrom(const TruncateLog& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .xtreemfs.pbrpc.TruncateRecord records = 1; + inline int records_size() const; + inline void clear_records(); + static const int kRecordsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::TruncateRecord& records(int index) const; + inline ::xtreemfs::pbrpc::TruncateRecord* mutable_records(int index); + inline ::xtreemfs::pbrpc::TruncateRecord* add_records(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::TruncateRecord >& + records() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::TruncateRecord >* + mutable_records(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.TruncateLog) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::TruncateRecord > records_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static TruncateLog* default_instance_; +}; +// ------------------------------------------------------------------- + +class XLocSetVersionState : public ::google::protobuf::Message { + public: + XLocSetVersionState(); + virtual ~XLocSetVersionState(); + + XLocSetVersionState(const XLocSetVersionState& from); + + inline XLocSetVersionState& operator=(const XLocSetVersionState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const XLocSetVersionState& default_instance(); + + void Swap(XLocSetVersionState* other); + + // implements Message ---------------------------------------------- + + XLocSetVersionState* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const XLocSetVersionState& from); + void MergeFrom(const XLocSetVersionState& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed32 version = 1; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 1; + inline ::google::protobuf::uint32 version() const; + inline void set_version(::google::protobuf::uint32 value); + + // required bool invalidated = 2; + inline bool has_invalidated() const; + inline void clear_invalidated(); + static const int kInvalidatedFieldNumber = 2; + inline bool invalidated() const; + inline void set_invalidated(bool value); + + // optional fixed64 modified_time = 3; + inline bool has_modified_time() const; + inline void clear_modified_time(); + static const int kModifiedTimeFieldNumber = 3; + inline ::google::protobuf::uint64 modified_time() const; + inline void set_modified_time(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.XLocSetVersionState) + private: + inline void set_has_version(); + inline void clear_has_version(); + inline void set_has_invalidated(); + inline void clear_has_invalidated(); + inline void set_has_modified_time(); + inline void clear_has_modified_time(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint32 version_; + bool invalidated_; + ::google::protobuf::uint64 modified_time_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static XLocSetVersionState* default_instance_; +}; +// ------------------------------------------------------------------- + +class ReplicaStatus : public ::google::protobuf::Message { + public: + ReplicaStatus(); + virtual ~ReplicaStatus(); + + ReplicaStatus(const ReplicaStatus& from); + + inline ReplicaStatus& operator=(const ReplicaStatus& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ReplicaStatus& default_instance(); + + void Swap(ReplicaStatus* other); + + // implements Message ---------------------------------------------- + + ReplicaStatus* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ReplicaStatus& from); + void MergeFrom(const ReplicaStatus& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 truncate_epoch = 1; + inline bool has_truncate_epoch() const; + inline void clear_truncate_epoch(); + static const int kTruncateEpochFieldNumber = 1; + inline ::google::protobuf::uint64 truncate_epoch() const; + inline void set_truncate_epoch(::google::protobuf::uint64 value); + + // required fixed64 file_size = 2; + inline bool has_file_size() const; + inline void clear_file_size(); + static const int kFileSizeFieldNumber = 2; + inline ::google::protobuf::uint64 file_size() const; + inline void set_file_size(::google::protobuf::uint64 value); + + // required fixed64 max_obj_version = 3; + inline bool has_max_obj_version() const; + inline void clear_max_obj_version(); + static const int kMaxObjVersionFieldNumber = 3; + inline ::google::protobuf::uint64 max_obj_version() const; + inline void set_max_obj_version(::google::protobuf::uint64 value); + + // required fixed32 primary_epoch = 4; + inline bool has_primary_epoch() const; + inline void clear_primary_epoch(); + static const int kPrimaryEpochFieldNumber = 4; + inline ::google::protobuf::uint32 primary_epoch() const; + inline void set_primary_epoch(::google::protobuf::uint32 value); + + // repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5; + inline int objectversions_size() const; + inline void clear_objectversions(); + static const int kObjectVersionsFieldNumber = 5; + inline const ::xtreemfs::pbrpc::ObjectVersion& objectversions(int index) const; + inline ::xtreemfs::pbrpc::ObjectVersion* mutable_objectversions(int index); + inline ::xtreemfs::pbrpc::ObjectVersion* add_objectversions(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersion >& + objectversions() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersion >* + mutable_objectversions(); + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 6; + inline bool has_truncate_log() const; + inline void clear_truncate_log(); + static const int kTruncateLogFieldNumber = 6; + inline const ::xtreemfs::pbrpc::TruncateLog& truncate_log() const; + inline ::xtreemfs::pbrpc::TruncateLog* mutable_truncate_log(); + inline ::xtreemfs::pbrpc::TruncateLog* release_truncate_log(); + inline void set_allocated_truncate_log(::xtreemfs::pbrpc::TruncateLog* truncate_log); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ReplicaStatus) + private: + inline void set_has_truncate_epoch(); + inline void clear_has_truncate_epoch(); + inline void set_has_file_size(); + inline void clear_has_file_size(); + inline void set_has_max_obj_version(); + inline void clear_has_max_obj_version(); + inline void set_has_primary_epoch(); + inline void clear_has_primary_epoch(); + inline void set_has_truncate_log(); + inline void clear_has_truncate_log(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 truncate_epoch_; + ::google::protobuf::uint64 file_size_; + ::google::protobuf::uint64 max_obj_version_; + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersion > objectversions_; + ::xtreemfs::pbrpc::TruncateLog* truncate_log_; + ::google::protobuf::uint32 primary_epoch_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static ReplicaStatus* default_instance_; +}; +// ------------------------------------------------------------------- + +class ObjectVersionMapping : public ::google::protobuf::Message { + public: + ObjectVersionMapping(); + virtual ~ObjectVersionMapping(); + + ObjectVersionMapping(const ObjectVersionMapping& from); + + inline ObjectVersionMapping& operator=(const ObjectVersionMapping& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ObjectVersionMapping& default_instance(); + + void Swap(ObjectVersionMapping* other); + + // implements Message ---------------------------------------------- + + ObjectVersionMapping* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ObjectVersionMapping& from); + void MergeFrom(const ObjectVersionMapping& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 object_number = 1; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 1; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 2; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 2; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // repeated string osd_uuids = 3; + inline int osd_uuids_size() const; + inline void clear_osd_uuids(); + static const int kOsdUuidsFieldNumber = 3; + inline const ::std::string& osd_uuids(int index) const; + inline ::std::string* mutable_osd_uuids(int index); + inline void set_osd_uuids(int index, const ::std::string& value); + inline void set_osd_uuids(int index, const char* value); + inline void set_osd_uuids(int index, const char* value, size_t size); + inline ::std::string* add_osd_uuids(); + inline void add_osd_uuids(const ::std::string& value); + inline void add_osd_uuids(const char* value); + inline void add_osd_uuids(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& osd_uuids() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_osd_uuids(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ObjectVersionMapping) + private: + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + ::google::protobuf::RepeatedPtrField< ::std::string> osd_uuids_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static ObjectVersionMapping* default_instance_; +}; +// ------------------------------------------------------------------- + +class AuthoritativeReplicaState : public ::google::protobuf::Message { + public: + AuthoritativeReplicaState(); + virtual ~AuthoritativeReplicaState(); + + AuthoritativeReplicaState(const AuthoritativeReplicaState& from); + + inline AuthoritativeReplicaState& operator=(const AuthoritativeReplicaState& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AuthoritativeReplicaState& default_instance(); + + void Swap(AuthoritativeReplicaState* other); + + // implements Message ---------------------------------------------- + + AuthoritativeReplicaState* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AuthoritativeReplicaState& from); + void MergeFrom(const AuthoritativeReplicaState& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 truncate_epoch = 1; + inline bool has_truncate_epoch() const; + inline void clear_truncate_epoch(); + static const int kTruncateEpochFieldNumber = 1; + inline ::google::protobuf::uint64 truncate_epoch() const; + inline void set_truncate_epoch(::google::protobuf::uint64 value); + + // required fixed64 max_obj_version = 4; + inline bool has_max_obj_version() const; + inline void clear_max_obj_version(); + static const int kMaxObjVersionFieldNumber = 4; + inline ::google::protobuf::uint64 max_obj_version() const; + inline void set_max_obj_version(::google::protobuf::uint64 value); + + // repeated .xtreemfs.pbrpc.ObjectVersionMapping objectVersions = 2; + inline int objectversions_size() const; + inline void clear_objectversions(); + static const int kObjectVersionsFieldNumber = 2; + inline const ::xtreemfs::pbrpc::ObjectVersionMapping& objectversions(int index) const; + inline ::xtreemfs::pbrpc::ObjectVersionMapping* mutable_objectversions(int index); + inline ::xtreemfs::pbrpc::ObjectVersionMapping* add_objectversions(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersionMapping >& + objectversions() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersionMapping >* + mutable_objectversions(); + + // required .xtreemfs.pbrpc.TruncateLog truncate_log = 3; + inline bool has_truncate_log() const; + inline void clear_truncate_log(); + static const int kTruncateLogFieldNumber = 3; + inline const ::xtreemfs::pbrpc::TruncateLog& truncate_log() const; + inline ::xtreemfs::pbrpc::TruncateLog* mutable_truncate_log(); + inline ::xtreemfs::pbrpc::TruncateLog* release_truncate_log(); + inline void set_allocated_truncate_log(::xtreemfs::pbrpc::TruncateLog* truncate_log); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.AuthoritativeReplicaState) + private: + inline void set_has_truncate_epoch(); + inline void clear_has_truncate_epoch(); + inline void set_has_max_obj_version(); + inline void clear_has_max_obj_version(); + inline void set_has_truncate_log(); + inline void clear_has_truncate_log(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 truncate_epoch_; + ::google::protobuf::uint64 max_obj_version_; + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersionMapping > objectversions_; + ::xtreemfs::pbrpc::TruncateLog* truncate_log_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static AuthoritativeReplicaState* default_instance_; +}; +// ------------------------------------------------------------------- + +class InternalReadLocalResponse : public ::google::protobuf::Message { + public: + InternalReadLocalResponse(); + virtual ~InternalReadLocalResponse(); + + InternalReadLocalResponse(const InternalReadLocalResponse& from); + + inline InternalReadLocalResponse& operator=(const InternalReadLocalResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const InternalReadLocalResponse& default_instance(); + + void Swap(InternalReadLocalResponse* other); + + // implements Message ---------------------------------------------- + + InternalReadLocalResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const InternalReadLocalResponse& from); + void MergeFrom(const InternalReadLocalResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.ObjectData data = 1; + inline bool has_data() const; + inline void clear_data(); + static const int kDataFieldNumber = 1; + inline const ::xtreemfs::pbrpc::ObjectData& data() const; + inline ::xtreemfs::pbrpc::ObjectData* mutable_data(); + inline ::xtreemfs::pbrpc::ObjectData* release_data(); + inline void set_allocated_data(::xtreemfs::pbrpc::ObjectData* data); + + // repeated .xtreemfs.pbrpc.ObjectList object_set = 2; + inline int object_set_size() const; + inline void clear_object_set(); + static const int kObjectSetFieldNumber = 2; + inline const ::xtreemfs::pbrpc::ObjectList& object_set(int index) const; + inline ::xtreemfs::pbrpc::ObjectList* mutable_object_set(int index); + inline ::xtreemfs::pbrpc::ObjectList* add_object_set(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList >& + object_set() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList >* + mutable_object_set(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.InternalReadLocalResponse) + private: + inline void set_has_data(); + inline void clear_has_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::ObjectData* data_; + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList > object_set_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static InternalReadLocalResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class readRequest : public ::google::protobuf::Message { + public: + readRequest(); + virtual ~readRequest(); + + readRequest(const readRequest& from); + + inline readRequest& operator=(const readRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const readRequest& default_instance(); + + void Swap(readRequest* other); + + // implements Message ---------------------------------------------- + + readRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const readRequest& from); + void MergeFrom(const readRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 object_number = 3; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 3; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 4; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 4; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // required fixed32 offset = 5; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 5; + inline ::google::protobuf::uint32 offset() const; + inline void set_offset(::google::protobuf::uint32 value); + + // required fixed32 length = 6; + inline bool has_length() const; + inline void clear_length(); + static const int kLengthFieldNumber = 6; + inline ::google::protobuf::uint32 length() const; + inline void set_length(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.readRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + inline void set_has_offset(); + inline void clear_has_offset(); + inline void set_has_length(); + inline void clear_has_length(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + ::google::protobuf::uint32 offset_; + ::google::protobuf::uint32 length_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static readRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class truncateRequest : public ::google::protobuf::Message { + public: + truncateRequest(); + virtual ~truncateRequest(); + + truncateRequest(const truncateRequest& from); + + inline truncateRequest& operator=(const truncateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const truncateRequest& default_instance(); + + void Swap(truncateRequest* other); + + // implements Message ---------------------------------------------- + + truncateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const truncateRequest& from); + void MergeFrom(const truncateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 new_file_size = 3; + inline bool has_new_file_size() const; + inline void clear_new_file_size(); + static const int kNewFileSizeFieldNumber = 3; + inline ::google::protobuf::uint64 new_file_size() const; + inline void set_new_file_size(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.truncateRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_new_file_size(); + inline void clear_has_new_file_size(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 new_file_size_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static truncateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class unlink_osd_Request : public ::google::protobuf::Message { + public: + unlink_osd_Request(); + virtual ~unlink_osd_Request(); + + unlink_osd_Request(const unlink_osd_Request& from); + + inline unlink_osd_Request& operator=(const unlink_osd_Request& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const unlink_osd_Request& default_instance(); + + void Swap(unlink_osd_Request* other); + + // implements Message ---------------------------------------------- + + unlink_osd_Request* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const unlink_osd_Request& from); + void MergeFrom(const unlink_osd_Request& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.unlink_osd_Request) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static unlink_osd_Request* default_instance_; +}; +// ------------------------------------------------------------------- + +class writeRequest : public ::google::protobuf::Message { + public: + writeRequest(); + virtual ~writeRequest(); + + writeRequest(const writeRequest& from); + + inline writeRequest& operator=(const writeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const writeRequest& default_instance(); + + void Swap(writeRequest* other); + + // implements Message ---------------------------------------------- + + writeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const writeRequest& from); + void MergeFrom(const writeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 object_number = 3; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 3; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 4; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 4; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // required fixed32 offset = 5; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 5; + inline ::google::protobuf::uint32 offset() const; + inline void set_offset(::google::protobuf::uint32 value); + + // required fixed64 lease_timeout = 6; + inline bool has_lease_timeout() const; + inline void clear_lease_timeout(); + static const int kLeaseTimeoutFieldNumber = 6; + inline ::google::protobuf::uint64 lease_timeout() const; + inline void set_lease_timeout(::google::protobuf::uint64 value); + + // required .xtreemfs.pbrpc.ObjectData object_data = 7; + inline bool has_object_data() const; + inline void clear_object_data(); + static const int kObjectDataFieldNumber = 7; + inline const ::xtreemfs::pbrpc::ObjectData& object_data() const; + inline ::xtreemfs::pbrpc::ObjectData* mutable_object_data(); + inline ::xtreemfs::pbrpc::ObjectData* release_object_data(); + inline void set_allocated_object_data(::xtreemfs::pbrpc::ObjectData* object_data); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.writeRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + inline void set_has_offset(); + inline void clear_has_offset(); + inline void set_has_lease_timeout(); + inline void clear_has_lease_timeout(); + inline void set_has_object_data(); + inline void clear_has_object_data(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + ::google::protobuf::uint64 lease_timeout_; + ::xtreemfs::pbrpc::ObjectData* object_data_; + ::google::protobuf::uint32 offset_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static writeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_broadcast_gmaxRequest : public ::google::protobuf::Message { + public: + xtreemfs_broadcast_gmaxRequest(); + virtual ~xtreemfs_broadcast_gmaxRequest(); + + xtreemfs_broadcast_gmaxRequest(const xtreemfs_broadcast_gmaxRequest& from); + + inline xtreemfs_broadcast_gmaxRequest& operator=(const xtreemfs_broadcast_gmaxRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_broadcast_gmaxRequest& default_instance(); + + void Swap(xtreemfs_broadcast_gmaxRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_broadcast_gmaxRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_broadcast_gmaxRequest& from); + void MergeFrom(const xtreemfs_broadcast_gmaxRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string file_id = 1; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 1; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 truncate_epoch = 2; + inline bool has_truncate_epoch() const; + inline void clear_truncate_epoch(); + static const int kTruncateEpochFieldNumber = 2; + inline ::google::protobuf::uint64 truncate_epoch() const; + inline void set_truncate_epoch(::google::protobuf::uint64 value); + + // required fixed64 last_object = 3; + inline bool has_last_object() const; + inline void clear_last_object(); + static const int kLastObjectFieldNumber = 3; + inline ::google::protobuf::uint64 last_object() const; + inline void set_last_object(::google::protobuf::uint64 value); + + // required fixed64 file_size = 4; + inline bool has_file_size() const; + inline void clear_file_size(); + static const int kFileSizeFieldNumber = 4; + inline ::google::protobuf::uint64 file_size() const; + inline void set_file_size(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_broadcast_gmaxRequest) + private: + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_truncate_epoch(); + inline void clear_has_truncate_epoch(); + inline void set_has_last_object(); + inline void clear_has_last_object(); + inline void set_has_file_size(); + inline void clear_has_file_size(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* file_id_; + ::google::protobuf::uint64 truncate_epoch_; + ::google::protobuf::uint64 last_object_; + ::google::protobuf::uint64 file_size_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_broadcast_gmaxRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_check_objectRequest : public ::google::protobuf::Message { + public: + xtreemfs_check_objectRequest(); + virtual ~xtreemfs_check_objectRequest(); + + xtreemfs_check_objectRequest(const xtreemfs_check_objectRequest& from); + + inline xtreemfs_check_objectRequest& operator=(const xtreemfs_check_objectRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_check_objectRequest& default_instance(); + + void Swap(xtreemfs_check_objectRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_check_objectRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_check_objectRequest& from); + void MergeFrom(const xtreemfs_check_objectRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 object_number = 3; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 3; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 4; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 4; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_check_objectRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_check_objectRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_cleanup_get_resultsResponse : public ::google::protobuf::Message { + public: + xtreemfs_cleanup_get_resultsResponse(); + virtual ~xtreemfs_cleanup_get_resultsResponse(); + + xtreemfs_cleanup_get_resultsResponse(const xtreemfs_cleanup_get_resultsResponse& from); + + inline xtreemfs_cleanup_get_resultsResponse& operator=(const xtreemfs_cleanup_get_resultsResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_cleanup_get_resultsResponse& default_instance(); + + void Swap(xtreemfs_cleanup_get_resultsResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_cleanup_get_resultsResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_cleanup_get_resultsResponse& from); + void MergeFrom(const xtreemfs_cleanup_get_resultsResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated string results = 1; + inline int results_size() const; + inline void clear_results(); + static const int kResultsFieldNumber = 1; + inline const ::std::string& results(int index) const; + inline ::std::string* mutable_results(int index); + inline void set_results(int index, const ::std::string& value); + inline void set_results(int index, const char* value); + inline void set_results(int index, const char* value, size_t size); + inline ::std::string* add_results(); + inline void add_results(const ::std::string& value); + inline void add_results(const char* value); + inline void add_results(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& results() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_results(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_cleanup_get_resultsResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::std::string> results_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_cleanup_get_resultsResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_cleanup_is_runningResponse : public ::google::protobuf::Message { + public: + xtreemfs_cleanup_is_runningResponse(); + virtual ~xtreemfs_cleanup_is_runningResponse(); + + xtreemfs_cleanup_is_runningResponse(const xtreemfs_cleanup_is_runningResponse& from); + + inline xtreemfs_cleanup_is_runningResponse& operator=(const xtreemfs_cleanup_is_runningResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_cleanup_is_runningResponse& default_instance(); + + void Swap(xtreemfs_cleanup_is_runningResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_cleanup_is_runningResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_cleanup_is_runningResponse& from); + void MergeFrom(const xtreemfs_cleanup_is_runningResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required bool is_running = 1; + inline bool has_is_running() const; + inline void clear_is_running(); + static const int kIsRunningFieldNumber = 1; + inline bool is_running() const; + inline void set_is_running(bool value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_cleanup_is_runningResponse) + private: + inline void set_has_is_running(); + inline void clear_has_is_running(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + bool is_running_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_cleanup_is_runningResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_cleanup_startRequest : public ::google::protobuf::Message { + public: + xtreemfs_cleanup_startRequest(); + virtual ~xtreemfs_cleanup_startRequest(); + + xtreemfs_cleanup_startRequest(const xtreemfs_cleanup_startRequest& from); + + inline xtreemfs_cleanup_startRequest& operator=(const xtreemfs_cleanup_startRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_cleanup_startRequest& default_instance(); + + void Swap(xtreemfs_cleanup_startRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_cleanup_startRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_cleanup_startRequest& from); + void MergeFrom(const xtreemfs_cleanup_startRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required bool remove_zombies = 1; + inline bool has_remove_zombies() const; + inline void clear_remove_zombies(); + static const int kRemoveZombiesFieldNumber = 1; + inline bool remove_zombies() const; + inline void set_remove_zombies(bool value); + + // required bool remove_unavail_volume = 2; + inline bool has_remove_unavail_volume() const; + inline void clear_remove_unavail_volume(); + static const int kRemoveUnavailVolumeFieldNumber = 2; + inline bool remove_unavail_volume() const; + inline void set_remove_unavail_volume(bool value); + + // required bool lost_and_found = 3; + inline bool has_lost_and_found() const; + inline void clear_lost_and_found(); + static const int kLostAndFoundFieldNumber = 3; + inline bool lost_and_found() const; + inline void set_lost_and_found(bool value); + + // required bool delete_metadata = 4; + inline bool has_delete_metadata() const; + inline void clear_delete_metadata(); + static const int kDeleteMetadataFieldNumber = 4; + inline bool delete_metadata() const; + inline void set_delete_metadata(bool value); + + // required fixed32 metadata_timeout = 5; + inline bool has_metadata_timeout() const; + inline void clear_metadata_timeout(); + static const int kMetadataTimeoutFieldNumber = 5; + inline ::google::protobuf::uint32 metadata_timeout() const; + inline void set_metadata_timeout(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_cleanup_startRequest) + private: + inline void set_has_remove_zombies(); + inline void clear_has_remove_zombies(); + inline void set_has_remove_unavail_volume(); + inline void clear_has_remove_unavail_volume(); + inline void set_has_lost_and_found(); + inline void clear_has_lost_and_found(); + inline void set_has_delete_metadata(); + inline void clear_has_delete_metadata(); + inline void set_has_metadata_timeout(); + inline void clear_has_metadata_timeout(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + bool remove_zombies_; + bool remove_unavail_volume_; + bool lost_and_found_; + bool delete_metadata_; + ::google::protobuf::uint32 metadata_timeout_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_cleanup_startRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_cleanup_statusResponse : public ::google::protobuf::Message { + public: + xtreemfs_cleanup_statusResponse(); + virtual ~xtreemfs_cleanup_statusResponse(); + + xtreemfs_cleanup_statusResponse(const xtreemfs_cleanup_statusResponse& from); + + inline xtreemfs_cleanup_statusResponse& operator=(const xtreemfs_cleanup_statusResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_cleanup_statusResponse& default_instance(); + + void Swap(xtreemfs_cleanup_statusResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_cleanup_statusResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_cleanup_statusResponse& from); + void MergeFrom(const xtreemfs_cleanup_statusResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string status = 1; + inline bool has_status() const; + inline void clear_status(); + static const int kStatusFieldNumber = 1; + inline const ::std::string& status() const; + inline void set_status(const ::std::string& value); + inline void set_status(const char* value); + inline void set_status(const char* value, size_t size); + inline ::std::string* mutable_status(); + inline ::std::string* release_status(); + inline void set_allocated_status(::std::string* status); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_cleanup_statusResponse) + private: + inline void set_has_status(); + inline void clear_has_status(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* status_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_cleanup_statusResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rwr_fetchRequest : public ::google::protobuf::Message { + public: + xtreemfs_rwr_fetchRequest(); + virtual ~xtreemfs_rwr_fetchRequest(); + + xtreemfs_rwr_fetchRequest(const xtreemfs_rwr_fetchRequest& from); + + inline xtreemfs_rwr_fetchRequest& operator=(const xtreemfs_rwr_fetchRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rwr_fetchRequest& default_instance(); + + void Swap(xtreemfs_rwr_fetchRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rwr_fetchRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rwr_fetchRequest& from); + void MergeFrom(const xtreemfs_rwr_fetchRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 object_number = 3; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 3; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 4; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 4; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rwr_fetchRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rwr_fetchRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_repair_objectRequest : public ::google::protobuf::Message { + public: + xtreemfs_repair_objectRequest(); + virtual ~xtreemfs_repair_objectRequest(); + + xtreemfs_repair_objectRequest(const xtreemfs_repair_objectRequest& from); + + inline xtreemfs_repair_objectRequest& operator=(const xtreemfs_repair_objectRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_repair_objectRequest& default_instance(); + + void Swap(xtreemfs_repair_objectRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_repair_objectRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_repair_objectRequest& from); + void MergeFrom(const xtreemfs_repair_objectRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 object_number = 3; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 3; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 4; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 4; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_repair_objectRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_repair_objectRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rwr_flease_msgRequest : public ::google::protobuf::Message { + public: + xtreemfs_rwr_flease_msgRequest(); + virtual ~xtreemfs_rwr_flease_msgRequest(); + + xtreemfs_rwr_flease_msgRequest(const xtreemfs_rwr_flease_msgRequest& from); + + inline xtreemfs_rwr_flease_msgRequest& operator=(const xtreemfs_rwr_flease_msgRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rwr_flease_msgRequest& default_instance(); + + void Swap(xtreemfs_rwr_flease_msgRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rwr_flease_msgRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rwr_flease_msgRequest& from); + void MergeFrom(const xtreemfs_rwr_flease_msgRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string sender_hostname = 1; + inline bool has_sender_hostname() const; + inline void clear_sender_hostname(); + static const int kSenderHostnameFieldNumber = 1; + inline const ::std::string& sender_hostname() const; + inline void set_sender_hostname(const ::std::string& value); + inline void set_sender_hostname(const char* value); + inline void set_sender_hostname(const char* value, size_t size); + inline ::std::string* mutable_sender_hostname(); + inline ::std::string* release_sender_hostname(); + inline void set_allocated_sender_hostname(::std::string* sender_hostname); + + // required fixed32 sender_port = 2; + inline bool has_sender_port() const; + inline void clear_sender_port(); + static const int kSenderPortFieldNumber = 2; + inline ::google::protobuf::uint32 sender_port() const; + inline void set_sender_port(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rwr_flease_msgRequest) + private: + inline void set_has_sender_hostname(); + inline void clear_has_sender_hostname(); + inline void set_has_sender_port(); + inline void clear_has_sender_port(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* sender_hostname_; + ::google::protobuf::uint32 sender_port_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rwr_flease_msgRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rwr_set_primary_epochRequest : public ::google::protobuf::Message { + public: + xtreemfs_rwr_set_primary_epochRequest(); + virtual ~xtreemfs_rwr_set_primary_epochRequest(); + + xtreemfs_rwr_set_primary_epochRequest(const xtreemfs_rwr_set_primary_epochRequest& from); + + inline xtreemfs_rwr_set_primary_epochRequest& operator=(const xtreemfs_rwr_set_primary_epochRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rwr_set_primary_epochRequest& default_instance(); + + void Swap(xtreemfs_rwr_set_primary_epochRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rwr_set_primary_epochRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rwr_set_primary_epochRequest& from); + void MergeFrom(const xtreemfs_rwr_set_primary_epochRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed32 primary_epoch = 3; + inline bool has_primary_epoch() const; + inline void clear_primary_epoch(); + static const int kPrimaryEpochFieldNumber = 3; + inline ::google::protobuf::uint32 primary_epoch() const; + inline void set_primary_epoch(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rwr_set_primary_epochRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_primary_epoch(); + inline void clear_has_primary_epoch(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint32 primary_epoch_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rwr_set_primary_epochRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rwr_statusRequest : public ::google::protobuf::Message { + public: + xtreemfs_rwr_statusRequest(); + virtual ~xtreemfs_rwr_statusRequest(); + + xtreemfs_rwr_statusRequest(const xtreemfs_rwr_statusRequest& from); + + inline xtreemfs_rwr_statusRequest& operator=(const xtreemfs_rwr_statusRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rwr_statusRequest& default_instance(); + + void Swap(xtreemfs_rwr_statusRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rwr_statusRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rwr_statusRequest& from); + void MergeFrom(const xtreemfs_rwr_statusRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 max_local_obj_version = 3; + inline bool has_max_local_obj_version() const; + inline void clear_max_local_obj_version(); + static const int kMaxLocalObjVersionFieldNumber = 3; + inline ::google::protobuf::uint64 max_local_obj_version() const; + inline void set_max_local_obj_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rwr_statusRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_max_local_obj_version(); + inline void clear_has_max_local_obj_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 max_local_obj_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rwr_statusRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rwr_truncateRequest : public ::google::protobuf::Message { + public: + xtreemfs_rwr_truncateRequest(); + virtual ~xtreemfs_rwr_truncateRequest(); + + xtreemfs_rwr_truncateRequest(const xtreemfs_rwr_truncateRequest& from); + + inline xtreemfs_rwr_truncateRequest& operator=(const xtreemfs_rwr_truncateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rwr_truncateRequest& default_instance(); + + void Swap(xtreemfs_rwr_truncateRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rwr_truncateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rwr_truncateRequest& from); + void MergeFrom(const xtreemfs_rwr_truncateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 new_file_size = 3; + inline bool has_new_file_size() const; + inline void clear_new_file_size(); + static const int kNewFileSizeFieldNumber = 3; + inline ::google::protobuf::uint64 new_file_size() const; + inline void set_new_file_size(::google::protobuf::uint64 value); + + // required fixed64 object_version = 4; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 4; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rwr_truncateRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_new_file_size(); + inline void clear_has_new_file_size(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 new_file_size_; + ::google::protobuf::uint64 object_version_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rwr_truncateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rwr_updateRequest : public ::google::protobuf::Message { + public: + xtreemfs_rwr_updateRequest(); + virtual ~xtreemfs_rwr_updateRequest(); + + xtreemfs_rwr_updateRequest(const xtreemfs_rwr_updateRequest& from); + + inline xtreemfs_rwr_updateRequest& operator=(const xtreemfs_rwr_updateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rwr_updateRequest& default_instance(); + + void Swap(xtreemfs_rwr_updateRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rwr_updateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rwr_updateRequest& from); + void MergeFrom(const xtreemfs_rwr_updateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 new_file_size = 3; + inline bool has_new_file_size() const; + inline void clear_new_file_size(); + static const int kNewFileSizeFieldNumber = 3; + inline ::google::protobuf::uint64 new_file_size() const; + inline void set_new_file_size(::google::protobuf::uint64 value); + + // required fixed64 object_number = 7; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 7; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 4; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 4; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // required fixed32 offset = 5; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 5; + inline ::google::protobuf::uint32 offset() const; + inline void set_offset(::google::protobuf::uint32 value); + + // required .xtreemfs.pbrpc.ObjectData obj = 6; + inline bool has_obj() const; + inline void clear_obj(); + static const int kObjFieldNumber = 6; + inline const ::xtreemfs::pbrpc::ObjectData& obj() const; + inline ::xtreemfs::pbrpc::ObjectData* mutable_obj(); + inline ::xtreemfs::pbrpc::ObjectData* release_obj(); + inline void set_allocated_obj(::xtreemfs::pbrpc::ObjectData* obj); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rwr_updateRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_new_file_size(); + inline void clear_has_new_file_size(); + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + inline void set_has_offset(); + inline void clear_has_offset(); + inline void set_has_obj(); + inline void clear_has_obj(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 new_file_size_; + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + ::xtreemfs::pbrpc::ObjectData* obj_; + ::google::protobuf::uint32 offset_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rwr_updateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_internal_get_gmaxRequest : public ::google::protobuf::Message { + public: + xtreemfs_internal_get_gmaxRequest(); + virtual ~xtreemfs_internal_get_gmaxRequest(); + + xtreemfs_internal_get_gmaxRequest(const xtreemfs_internal_get_gmaxRequest& from); + + inline xtreemfs_internal_get_gmaxRequest& operator=(const xtreemfs_internal_get_gmaxRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_internal_get_gmaxRequest& default_instance(); + + void Swap(xtreemfs_internal_get_gmaxRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_internal_get_gmaxRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_internal_get_gmaxRequest& from); + void MergeFrom(const xtreemfs_internal_get_gmaxRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_internal_get_gmaxRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_internal_get_gmaxRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_internal_get_file_sizeRequest : public ::google::protobuf::Message { + public: + xtreemfs_internal_get_file_sizeRequest(); + virtual ~xtreemfs_internal_get_file_sizeRequest(); + + xtreemfs_internal_get_file_sizeRequest(const xtreemfs_internal_get_file_sizeRequest& from); + + inline xtreemfs_internal_get_file_sizeRequest& operator=(const xtreemfs_internal_get_file_sizeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_internal_get_file_sizeRequest& default_instance(); + + void Swap(xtreemfs_internal_get_file_sizeRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_internal_get_file_sizeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_internal_get_file_sizeRequest& from); + void MergeFrom(const xtreemfs_internal_get_file_sizeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_internal_get_file_sizeRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_internal_get_file_sizeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_internal_get_file_sizeResponse : public ::google::protobuf::Message { + public: + xtreemfs_internal_get_file_sizeResponse(); + virtual ~xtreemfs_internal_get_file_sizeResponse(); + + xtreemfs_internal_get_file_sizeResponse(const xtreemfs_internal_get_file_sizeResponse& from); + + inline xtreemfs_internal_get_file_sizeResponse& operator=(const xtreemfs_internal_get_file_sizeResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_internal_get_file_sizeResponse& default_instance(); + + void Swap(xtreemfs_internal_get_file_sizeResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_internal_get_file_sizeResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_internal_get_file_sizeResponse& from); + void MergeFrom(const xtreemfs_internal_get_file_sizeResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required fixed64 file_size = 1; + inline bool has_file_size() const; + inline void clear_file_size(); + static const int kFileSizeFieldNumber = 1; + inline ::google::protobuf::uint64 file_size() const; + inline void set_file_size(::google::protobuf::uint64 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_internal_get_file_sizeResponse) + private: + inline void set_has_file_size(); + inline void clear_has_file_size(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::uint64 file_size_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_internal_get_file_sizeResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_internal_read_localRequest : public ::google::protobuf::Message { + public: + xtreemfs_internal_read_localRequest(); + virtual ~xtreemfs_internal_read_localRequest(); + + xtreemfs_internal_read_localRequest(const xtreemfs_internal_read_localRequest& from); + + inline xtreemfs_internal_read_localRequest& operator=(const xtreemfs_internal_read_localRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_internal_read_localRequest& default_instance(); + + void Swap(xtreemfs_internal_read_localRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_internal_read_localRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_internal_read_localRequest& from); + void MergeFrom(const xtreemfs_internal_read_localRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed64 object_number = 3; + inline bool has_object_number() const; + inline void clear_object_number(); + static const int kObjectNumberFieldNumber = 3; + inline ::google::protobuf::uint64 object_number() const; + inline void set_object_number(::google::protobuf::uint64 value); + + // required fixed64 object_version = 4; + inline bool has_object_version() const; + inline void clear_object_version(); + static const int kObjectVersionFieldNumber = 4; + inline ::google::protobuf::uint64 object_version() const; + inline void set_object_version(::google::protobuf::uint64 value); + + // required fixed32 offset = 5; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 5; + inline ::google::protobuf::uint32 offset() const; + inline void set_offset(::google::protobuf::uint32 value); + + // required fixed32 length = 6; + inline bool has_length() const; + inline void clear_length(); + static const int kLengthFieldNumber = 6; + inline ::google::protobuf::uint32 length() const; + inline void set_length(::google::protobuf::uint32 value); + + // required bool attach_object_list = 7; + inline bool has_attach_object_list() const; + inline void clear_attach_object_list(); + static const int kAttachObjectListFieldNumber = 7; + inline bool attach_object_list() const; + inline void set_attach_object_list(bool value); + + // repeated .xtreemfs.pbrpc.ObjectList required_objects = 8; + inline int required_objects_size() const; + inline void clear_required_objects(); + static const int kRequiredObjectsFieldNumber = 8; + inline const ::xtreemfs::pbrpc::ObjectList& required_objects(int index) const; + inline ::xtreemfs::pbrpc::ObjectList* mutable_required_objects(int index); + inline ::xtreemfs::pbrpc::ObjectList* add_required_objects(); + inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList >& + required_objects() const; + inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList >* + mutable_required_objects(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_internal_read_localRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_object_number(); + inline void clear_has_object_number(); + inline void set_has_object_version(); + inline void clear_has_object_version(); + inline void set_has_offset(); + inline void clear_has_offset(); + inline void set_has_length(); + inline void clear_has_length(); + inline void set_has_attach_object_list(); + inline void clear_has_attach_object_list(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint64 object_number_; + ::google::protobuf::uint64 object_version_; + ::google::protobuf::uint32 offset_; + ::google::protobuf::uint32 length_; + ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList > required_objects_; + bool attach_object_list_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_internal_read_localRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_internal_get_object_setRequest : public ::google::protobuf::Message { + public: + xtreemfs_internal_get_object_setRequest(); + virtual ~xtreemfs_internal_get_object_setRequest(); + + xtreemfs_internal_get_object_setRequest(const xtreemfs_internal_get_object_setRequest& from); + + inline xtreemfs_internal_get_object_setRequest& operator=(const xtreemfs_internal_get_object_setRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_internal_get_object_setRequest& default_instance(); + + void Swap(xtreemfs_internal_get_object_setRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_internal_get_object_setRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_internal_get_object_setRequest& from); + void MergeFrom(const xtreemfs_internal_get_object_setRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_internal_get_object_setRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_internal_get_object_setRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_internal_get_fileid_listResponse : public ::google::protobuf::Message { + public: + xtreemfs_internal_get_fileid_listResponse(); + virtual ~xtreemfs_internal_get_fileid_listResponse(); + + xtreemfs_internal_get_fileid_listResponse(const xtreemfs_internal_get_fileid_listResponse& from); + + inline xtreemfs_internal_get_fileid_listResponse& operator=(const xtreemfs_internal_get_fileid_listResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_internal_get_fileid_listResponse& default_instance(); + + void Swap(xtreemfs_internal_get_fileid_listResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_internal_get_fileid_listResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_internal_get_fileid_listResponse& from); + void MergeFrom(const xtreemfs_internal_get_fileid_listResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated string file_ids = 1; + inline int file_ids_size() const; + inline void clear_file_ids(); + static const int kFileIdsFieldNumber = 1; + inline const ::std::string& file_ids(int index) const; + inline ::std::string* mutable_file_ids(int index); + inline void set_file_ids(int index, const ::std::string& value); + inline void set_file_ids(int index, const char* value); + inline void set_file_ids(int index, const char* value, size_t size); + inline ::std::string* add_file_ids(); + inline void add_file_ids(const ::std::string& value); + inline void add_file_ids(const char* value); + inline void add_file_ids(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& file_ids() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_file_ids(); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_internal_get_fileid_listResponse) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::std::string> file_ids_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_internal_get_fileid_listResponse* default_instance_; +}; +// ------------------------------------------------------------------- + +class lockRequest : public ::google::protobuf::Message { + public: + lockRequest(); + virtual ~lockRequest(); + + lockRequest(const lockRequest& from); + + inline lockRequest& operator=(const lockRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const lockRequest& default_instance(); + + void Swap(lockRequest* other); + + // implements Message ---------------------------------------------- + + lockRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const lockRequest& from); + void MergeFrom(const lockRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required .xtreemfs.pbrpc.Lock lock_request = 2; + inline bool has_lock_request() const; + inline void clear_lock_request(); + static const int kLockRequestFieldNumber = 2; + inline const ::xtreemfs::pbrpc::Lock& lock_request() const; + inline ::xtreemfs::pbrpc::Lock* mutable_lock_request(); + inline ::xtreemfs::pbrpc::Lock* release_lock_request(); + inline void set_allocated_lock_request(::xtreemfs::pbrpc::Lock* lock_request); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.lockRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_lock_request(); + inline void clear_has_lock_request(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::xtreemfs::pbrpc::Lock* lock_request_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static lockRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_pingMesssage : public ::google::protobuf::Message { + public: + xtreemfs_pingMesssage(); + virtual ~xtreemfs_pingMesssage(); + + xtreemfs_pingMesssage(const xtreemfs_pingMesssage& from); + + inline xtreemfs_pingMesssage& operator=(const xtreemfs_pingMesssage& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_pingMesssage& default_instance(); + + void Swap(xtreemfs_pingMesssage* other); + + // implements Message ---------------------------------------------- + + xtreemfs_pingMesssage* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_pingMesssage& from); + void MergeFrom(const xtreemfs_pingMesssage& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 1; + inline bool has_coordinates() const; + inline void clear_coordinates(); + static const int kCoordinatesFieldNumber = 1; + inline const ::xtreemfs::pbrpc::VivaldiCoordinates& coordinates() const; + inline ::xtreemfs::pbrpc::VivaldiCoordinates* mutable_coordinates(); + inline ::xtreemfs::pbrpc::VivaldiCoordinates* release_coordinates(); + inline void set_allocated_coordinates(::xtreemfs::pbrpc::VivaldiCoordinates* coordinates); + + // required bool request_response = 2; + inline bool has_request_response() const; + inline void clear_request_response(); + static const int kRequestResponseFieldNumber = 2; + inline bool request_response() const; + inline void set_request_response(bool value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_pingMesssage) + private: + inline void set_has_coordinates(); + inline void clear_has_coordinates(); + inline void set_has_request_response(); + inline void clear_has_request_response(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::VivaldiCoordinates* coordinates_; + bool request_response_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_pingMesssage* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rwr_auth_stateRequest : public ::google::protobuf::Message { + public: + xtreemfs_rwr_auth_stateRequest(); + virtual ~xtreemfs_rwr_auth_stateRequest(); + + xtreemfs_rwr_auth_stateRequest(const xtreemfs_rwr_auth_stateRequest& from); + + inline xtreemfs_rwr_auth_stateRequest& operator=(const xtreemfs_rwr_auth_stateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rwr_auth_stateRequest& default_instance(); + + void Swap(xtreemfs_rwr_auth_stateRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rwr_auth_stateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rwr_auth_stateRequest& from); + void MergeFrom(const xtreemfs_rwr_auth_stateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required .xtreemfs.pbrpc.AuthoritativeReplicaState state = 3; + inline bool has_state() const; + inline void clear_state(); + static const int kStateFieldNumber = 3; + inline const ::xtreemfs::pbrpc::AuthoritativeReplicaState& state() const; + inline ::xtreemfs::pbrpc::AuthoritativeReplicaState* mutable_state(); + inline ::xtreemfs::pbrpc::AuthoritativeReplicaState* release_state(); + inline void set_allocated_state(::xtreemfs::pbrpc::AuthoritativeReplicaState* state); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rwr_auth_stateRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_state(); + inline void clear_has_state(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::xtreemfs::pbrpc::AuthoritativeReplicaState* state_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rwr_auth_stateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_rwr_reset_completeRequest : public ::google::protobuf::Message { + public: + xtreemfs_rwr_reset_completeRequest(); + virtual ~xtreemfs_rwr_reset_completeRequest(); + + xtreemfs_rwr_reset_completeRequest(const xtreemfs_rwr_reset_completeRequest& from); + + inline xtreemfs_rwr_reset_completeRequest& operator=(const xtreemfs_rwr_reset_completeRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_rwr_reset_completeRequest& default_instance(); + + void Swap(xtreemfs_rwr_reset_completeRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_rwr_reset_completeRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_rwr_reset_completeRequest& from); + void MergeFrom(const xtreemfs_rwr_reset_completeRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // required fixed32 primary_epoch = 3; + inline bool has_primary_epoch() const; + inline void clear_primary_epoch(); + static const int kPrimaryEpochFieldNumber = 3; + inline ::google::protobuf::uint32 primary_epoch() const; + inline void set_primary_epoch(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_rwr_reset_completeRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + inline void set_has_primary_epoch(); + inline void clear_has_primary_epoch(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + ::google::protobuf::uint32 primary_epoch_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_rwr_reset_completeRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_xloc_set_invalidateRequest : public ::google::protobuf::Message { + public: + xtreemfs_xloc_set_invalidateRequest(); + virtual ~xtreemfs_xloc_set_invalidateRequest(); + + xtreemfs_xloc_set_invalidateRequest(const xtreemfs_xloc_set_invalidateRequest& from); + + inline xtreemfs_xloc_set_invalidateRequest& operator=(const xtreemfs_xloc_set_invalidateRequest& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_xloc_set_invalidateRequest& default_instance(); + + void Swap(xtreemfs_xloc_set_invalidateRequest* other); + + // implements Message ---------------------------------------------- + + xtreemfs_xloc_set_invalidateRequest* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_xloc_set_invalidateRequest& from); + void MergeFrom(const xtreemfs_xloc_set_invalidateRequest& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; + inline bool has_file_credentials() const; + inline void clear_file_credentials(); + static const int kFileCredentialsFieldNumber = 1; + inline const ::xtreemfs::pbrpc::FileCredentials& file_credentials() const; + inline ::xtreemfs::pbrpc::FileCredentials* mutable_file_credentials(); + inline ::xtreemfs::pbrpc::FileCredentials* release_file_credentials(); + inline void set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials); + + // required string file_id = 2; + inline bool has_file_id() const; + inline void clear_file_id(); + static const int kFileIdFieldNumber = 2; + inline const ::std::string& file_id() const; + inline void set_file_id(const ::std::string& value); + inline void set_file_id(const char* value); + inline void set_file_id(const char* value, size_t size); + inline ::std::string* mutable_file_id(); + inline ::std::string* release_file_id(); + inline void set_allocated_file_id(::std::string* file_id); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_xloc_set_invalidateRequest) + private: + inline void set_has_file_credentials(); + inline void clear_has_file_credentials(); + inline void set_has_file_id(); + inline void clear_has_file_id(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::FileCredentials* file_credentials_; + ::std::string* file_id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_xloc_set_invalidateRequest* default_instance_; +}; +// ------------------------------------------------------------------- + +class xtreemfs_xloc_set_invalidateResponse : public ::google::protobuf::Message { + public: + xtreemfs_xloc_set_invalidateResponse(); + virtual ~xtreemfs_xloc_set_invalidateResponse(); + + xtreemfs_xloc_set_invalidateResponse(const xtreemfs_xloc_set_invalidateResponse& from); + + inline xtreemfs_xloc_set_invalidateResponse& operator=(const xtreemfs_xloc_set_invalidateResponse& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const xtreemfs_xloc_set_invalidateResponse& default_instance(); + + void Swap(xtreemfs_xloc_set_invalidateResponse* other); + + // implements Message ---------------------------------------------- + + xtreemfs_xloc_set_invalidateResponse* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const xtreemfs_xloc_set_invalidateResponse& from); + void MergeFrom(const xtreemfs_xloc_set_invalidateResponse& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .xtreemfs.pbrpc.LeaseState lease_state = 1; + inline bool has_lease_state() const; + inline void clear_lease_state(); + static const int kLeaseStateFieldNumber = 1; + inline ::xtreemfs::pbrpc::LeaseState lease_state() const; + inline void set_lease_state(::xtreemfs::pbrpc::LeaseState value); + + // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2; + inline bool has_replica_status() const; + inline void clear_replica_status(); + static const int kReplicaStatusFieldNumber = 2; + inline const ::xtreemfs::pbrpc::ReplicaStatus& replica_status() const; + inline ::xtreemfs::pbrpc::ReplicaStatus* mutable_replica_status(); + inline ::xtreemfs::pbrpc::ReplicaStatus* release_replica_status(); + inline void set_allocated_replica_status(::xtreemfs::pbrpc::ReplicaStatus* replica_status); + + // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_xloc_set_invalidateResponse) + private: + inline void set_has_lease_state(); + inline void clear_has_lease_state(); + inline void set_has_replica_status(); + inline void clear_has_replica_status(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::xtreemfs::pbrpc::ReplicaStatus* replica_status_; + int lease_state_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto(); + friend void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto(); + + void InitAsDefaultInstance(); + static xtreemfs_xloc_set_invalidateResponse* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// InternalGmax + +// required fixed64 epoch = 1; +inline bool InternalGmax::has_epoch() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void InternalGmax::set_has_epoch() { + _has_bits_[0] |= 0x00000001u; +} +inline void InternalGmax::clear_has_epoch() { + _has_bits_[0] &= ~0x00000001u; +} +inline void InternalGmax::clear_epoch() { + epoch_ = GOOGLE_ULONGLONG(0); + clear_has_epoch(); +} +inline ::google::protobuf::uint64 InternalGmax::epoch() const { + return epoch_; +} +inline void InternalGmax::set_epoch(::google::protobuf::uint64 value) { + set_has_epoch(); + epoch_ = value; +} + +// required fixed64 file_size = 2; +inline bool InternalGmax::has_file_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void InternalGmax::set_has_file_size() { + _has_bits_[0] |= 0x00000002u; +} +inline void InternalGmax::clear_has_file_size() { + _has_bits_[0] &= ~0x00000002u; +} +inline void InternalGmax::clear_file_size() { + file_size_ = GOOGLE_ULONGLONG(0); + clear_has_file_size(); +} +inline ::google::protobuf::uint64 InternalGmax::file_size() const { + return file_size_; +} +inline void InternalGmax::set_file_size(::google::protobuf::uint64 value) { + set_has_file_size(); + file_size_ = value; +} + +// required fixed64 last_object_id = 3; +inline bool InternalGmax::has_last_object_id() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void InternalGmax::set_has_last_object_id() { + _has_bits_[0] |= 0x00000004u; +} +inline void InternalGmax::clear_has_last_object_id() { + _has_bits_[0] &= ~0x00000004u; +} +inline void InternalGmax::clear_last_object_id() { + last_object_id_ = GOOGLE_ULONGLONG(0); + clear_has_last_object_id(); +} +inline ::google::protobuf::uint64 InternalGmax::last_object_id() const { + return last_object_id_; +} +inline void InternalGmax::set_last_object_id(::google::protobuf::uint64 value) { + set_has_last_object_id(); + last_object_id_ = value; +} + +// ------------------------------------------------------------------- + +// Lock + +// required fixed32 client_pid = 1; +inline bool Lock::has_client_pid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Lock::set_has_client_pid() { + _has_bits_[0] |= 0x00000001u; +} +inline void Lock::clear_has_client_pid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Lock::clear_client_pid() { + client_pid_ = 0u; + clear_has_client_pid(); +} +inline ::google::protobuf::uint32 Lock::client_pid() const { + return client_pid_; +} +inline void Lock::set_client_pid(::google::protobuf::uint32 value) { + set_has_client_pid(); + client_pid_ = value; +} + +// required string client_uuid = 2; +inline bool Lock::has_client_uuid() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Lock::set_has_client_uuid() { + _has_bits_[0] |= 0x00000002u; +} +inline void Lock::clear_has_client_uuid() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Lock::clear_client_uuid() { + if (client_uuid_ != &::google::protobuf::internal::kEmptyString) { + client_uuid_->clear(); + } + clear_has_client_uuid(); +} +inline const ::std::string& Lock::client_uuid() const { + return *client_uuid_; +} +inline void Lock::set_client_uuid(const ::std::string& value) { + set_has_client_uuid(); + if (client_uuid_ == &::google::protobuf::internal::kEmptyString) { + client_uuid_ = new ::std::string; + } + client_uuid_->assign(value); +} +inline void Lock::set_client_uuid(const char* value) { + set_has_client_uuid(); + if (client_uuid_ == &::google::protobuf::internal::kEmptyString) { + client_uuid_ = new ::std::string; + } + client_uuid_->assign(value); +} +inline void Lock::set_client_uuid(const char* value, size_t size) { + set_has_client_uuid(); + if (client_uuid_ == &::google::protobuf::internal::kEmptyString) { + client_uuid_ = new ::std::string; + } + client_uuid_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Lock::mutable_client_uuid() { + set_has_client_uuid(); + if (client_uuid_ == &::google::protobuf::internal::kEmptyString) { + client_uuid_ = new ::std::string; + } + return client_uuid_; +} +inline ::std::string* Lock::release_client_uuid() { + clear_has_client_uuid(); + if (client_uuid_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = client_uuid_; + client_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Lock::set_allocated_client_uuid(::std::string* client_uuid) { + if (client_uuid_ != &::google::protobuf::internal::kEmptyString) { + delete client_uuid_; + } + if (client_uuid) { + set_has_client_uuid(); + client_uuid_ = client_uuid; + } else { + clear_has_client_uuid(); + client_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 length = 3; +inline bool Lock::has_length() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Lock::set_has_length() { + _has_bits_[0] |= 0x00000004u; +} +inline void Lock::clear_has_length() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Lock::clear_length() { + length_ = GOOGLE_ULONGLONG(0); + clear_has_length(); +} +inline ::google::protobuf::uint64 Lock::length() const { + return length_; +} +inline void Lock::set_length(::google::protobuf::uint64 value) { + set_has_length(); + length_ = value; +} + +// required fixed64 offset = 4; +inline bool Lock::has_offset() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void Lock::set_has_offset() { + _has_bits_[0] |= 0x00000008u; +} +inline void Lock::clear_has_offset() { + _has_bits_[0] &= ~0x00000008u; +} +inline void Lock::clear_offset() { + offset_ = GOOGLE_ULONGLONG(0); + clear_has_offset(); +} +inline ::google::protobuf::uint64 Lock::offset() const { + return offset_; +} +inline void Lock::set_offset(::google::protobuf::uint64 value) { + set_has_offset(); + offset_ = value; +} + +// required bool exclusive = 5; +inline bool Lock::has_exclusive() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void Lock::set_has_exclusive() { + _has_bits_[0] |= 0x00000010u; +} +inline void Lock::clear_has_exclusive() { + _has_bits_[0] &= ~0x00000010u; +} +inline void Lock::clear_exclusive() { + exclusive_ = false; + clear_has_exclusive(); +} +inline bool Lock::exclusive() const { + return exclusive_; +} +inline void Lock::set_exclusive(bool value) { + set_has_exclusive(); + exclusive_ = value; +} + +// ------------------------------------------------------------------- + +// ObjectData + +// required fixed32 checksum = 1; +inline bool ObjectData::has_checksum() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ObjectData::set_has_checksum() { + _has_bits_[0] |= 0x00000001u; +} +inline void ObjectData::clear_has_checksum() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ObjectData::clear_checksum() { + checksum_ = 0u; + clear_has_checksum(); +} +inline ::google::protobuf::uint32 ObjectData::checksum() const { + return checksum_; +} +inline void ObjectData::set_checksum(::google::protobuf::uint32 value) { + set_has_checksum(); + checksum_ = value; +} + +// required bool invalid_checksum_on_osd = 2; +inline bool ObjectData::has_invalid_checksum_on_osd() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ObjectData::set_has_invalid_checksum_on_osd() { + _has_bits_[0] |= 0x00000002u; +} +inline void ObjectData::clear_has_invalid_checksum_on_osd() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ObjectData::clear_invalid_checksum_on_osd() { + invalid_checksum_on_osd_ = false; + clear_has_invalid_checksum_on_osd(); +} +inline bool ObjectData::invalid_checksum_on_osd() const { + return invalid_checksum_on_osd_; +} +inline void ObjectData::set_invalid_checksum_on_osd(bool value) { + set_has_invalid_checksum_on_osd(); + invalid_checksum_on_osd_ = value; +} + +// required fixed32 zero_padding = 3; +inline bool ObjectData::has_zero_padding() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ObjectData::set_has_zero_padding() { + _has_bits_[0] |= 0x00000004u; +} +inline void ObjectData::clear_has_zero_padding() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ObjectData::clear_zero_padding() { + zero_padding_ = 0u; + clear_has_zero_padding(); +} +inline ::google::protobuf::uint32 ObjectData::zero_padding() const { + return zero_padding_; +} +inline void ObjectData::set_zero_padding(::google::protobuf::uint32 value) { + set_has_zero_padding(); + zero_padding_ = value; +} + +// ------------------------------------------------------------------- + +// ObjectList + +// required bytes set = 1; +inline bool ObjectList::has_set() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ObjectList::set_has_set() { + _has_bits_[0] |= 0x00000001u; +} +inline void ObjectList::clear_has_set() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ObjectList::clear_set() { + if (set_ != &::google::protobuf::internal::kEmptyString) { + set_->clear(); + } + clear_has_set(); +} +inline const ::std::string& ObjectList::set() const { + return *set_; +} +inline void ObjectList::set_set(const ::std::string& value) { + set_has_set(); + if (set_ == &::google::protobuf::internal::kEmptyString) { + set_ = new ::std::string; + } + set_->assign(value); +} +inline void ObjectList::set_set(const char* value) { + set_has_set(); + if (set_ == &::google::protobuf::internal::kEmptyString) { + set_ = new ::std::string; + } + set_->assign(value); +} +inline void ObjectList::set_set(const void* value, size_t size) { + set_has_set(); + if (set_ == &::google::protobuf::internal::kEmptyString) { + set_ = new ::std::string; + } + set_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ObjectList::mutable_set() { + set_has_set(); + if (set_ == &::google::protobuf::internal::kEmptyString) { + set_ = new ::std::string; + } + return set_; +} +inline ::std::string* ObjectList::release_set() { + clear_has_set(); + if (set_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = set_; + set_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void ObjectList::set_allocated_set(::std::string* set) { + if (set_ != &::google::protobuf::internal::kEmptyString) { + delete set_; + } + if (set) { + set_has_set(); + set_ = set; + } else { + clear_has_set(); + set_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 stripe_width = 2; +inline bool ObjectList::has_stripe_width() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ObjectList::set_has_stripe_width() { + _has_bits_[0] |= 0x00000002u; +} +inline void ObjectList::clear_has_stripe_width() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ObjectList::clear_stripe_width() { + stripe_width_ = 0u; + clear_has_stripe_width(); +} +inline ::google::protobuf::uint32 ObjectList::stripe_width() const { + return stripe_width_; +} +inline void ObjectList::set_stripe_width(::google::protobuf::uint32 value) { + set_has_stripe_width(); + stripe_width_ = value; +} + +// required fixed32 first_ = 3; +inline bool ObjectList::has_first_() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ObjectList::set_has_first_() { + _has_bits_[0] |= 0x00000004u; +} +inline void ObjectList::clear_has_first_() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ObjectList::clear_first_() { + first__ = 0u; + clear_has_first_(); +} +inline ::google::protobuf::uint32 ObjectList::first_() const { + return first__; +} +inline void ObjectList::set_first_(::google::protobuf::uint32 value) { + set_has_first_(); + first__ = value; +} + +// ------------------------------------------------------------------- + +// ObjectVersion + +// required fixed64 object_number = 1; +inline bool ObjectVersion::has_object_number() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ObjectVersion::set_has_object_number() { + _has_bits_[0] |= 0x00000001u; +} +inline void ObjectVersion::clear_has_object_number() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ObjectVersion::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 ObjectVersion::object_number() const { + return object_number_; +} +inline void ObjectVersion::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 2; +inline bool ObjectVersion::has_object_version() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ObjectVersion::set_has_object_version() { + _has_bits_[0] |= 0x00000002u; +} +inline void ObjectVersion::clear_has_object_version() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ObjectVersion::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 ObjectVersion::object_version() const { + return object_version_; +} +inline void ObjectVersion::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// ------------------------------------------------------------------- + +// TruncateRecord + +// required fixed64 version = 1; +inline bool TruncateRecord::has_version() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void TruncateRecord::set_has_version() { + _has_bits_[0] |= 0x00000001u; +} +inline void TruncateRecord::clear_has_version() { + _has_bits_[0] &= ~0x00000001u; +} +inline void TruncateRecord::clear_version() { + version_ = GOOGLE_ULONGLONG(0); + clear_has_version(); +} +inline ::google::protobuf::uint64 TruncateRecord::version() const { + return version_; +} +inline void TruncateRecord::set_version(::google::protobuf::uint64 value) { + set_has_version(); + version_ = value; +} + +// required fixed64 last_object_number = 2; +inline bool TruncateRecord::has_last_object_number() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void TruncateRecord::set_has_last_object_number() { + _has_bits_[0] |= 0x00000002u; +} +inline void TruncateRecord::clear_has_last_object_number() { + _has_bits_[0] &= ~0x00000002u; +} +inline void TruncateRecord::clear_last_object_number() { + last_object_number_ = GOOGLE_ULONGLONG(0); + clear_has_last_object_number(); +} +inline ::google::protobuf::uint64 TruncateRecord::last_object_number() const { + return last_object_number_; +} +inline void TruncateRecord::set_last_object_number(::google::protobuf::uint64 value) { + set_has_last_object_number(); + last_object_number_ = value; +} + +// ------------------------------------------------------------------- + +// TruncateLog + +// repeated .xtreemfs.pbrpc.TruncateRecord records = 1; +inline int TruncateLog::records_size() const { + return records_.size(); +} +inline void TruncateLog::clear_records() { + records_.Clear(); +} +inline const ::xtreemfs::pbrpc::TruncateRecord& TruncateLog::records(int index) const { + return records_.Get(index); +} +inline ::xtreemfs::pbrpc::TruncateRecord* TruncateLog::mutable_records(int index) { + return records_.Mutable(index); +} +inline ::xtreemfs::pbrpc::TruncateRecord* TruncateLog::add_records() { + return records_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::TruncateRecord >& +TruncateLog::records() const { + return records_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::TruncateRecord >* +TruncateLog::mutable_records() { + return &records_; +} + +// ------------------------------------------------------------------- + +// XLocSetVersionState + +// required fixed32 version = 1; +inline bool XLocSetVersionState::has_version() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void XLocSetVersionState::set_has_version() { + _has_bits_[0] |= 0x00000001u; +} +inline void XLocSetVersionState::clear_has_version() { + _has_bits_[0] &= ~0x00000001u; +} +inline void XLocSetVersionState::clear_version() { + version_ = 0u; + clear_has_version(); +} +inline ::google::protobuf::uint32 XLocSetVersionState::version() const { + return version_; +} +inline void XLocSetVersionState::set_version(::google::protobuf::uint32 value) { + set_has_version(); + version_ = value; +} + +// required bool invalidated = 2; +inline bool XLocSetVersionState::has_invalidated() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void XLocSetVersionState::set_has_invalidated() { + _has_bits_[0] |= 0x00000002u; +} +inline void XLocSetVersionState::clear_has_invalidated() { + _has_bits_[0] &= ~0x00000002u; +} +inline void XLocSetVersionState::clear_invalidated() { + invalidated_ = false; + clear_has_invalidated(); +} +inline bool XLocSetVersionState::invalidated() const { + return invalidated_; +} +inline void XLocSetVersionState::set_invalidated(bool value) { + set_has_invalidated(); + invalidated_ = value; +} + +// optional fixed64 modified_time = 3; +inline bool XLocSetVersionState::has_modified_time() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void XLocSetVersionState::set_has_modified_time() { + _has_bits_[0] |= 0x00000004u; +} +inline void XLocSetVersionState::clear_has_modified_time() { + _has_bits_[0] &= ~0x00000004u; +} +inline void XLocSetVersionState::clear_modified_time() { + modified_time_ = GOOGLE_ULONGLONG(0); + clear_has_modified_time(); +} +inline ::google::protobuf::uint64 XLocSetVersionState::modified_time() const { + return modified_time_; +} +inline void XLocSetVersionState::set_modified_time(::google::protobuf::uint64 value) { + set_has_modified_time(); + modified_time_ = value; +} + +// ------------------------------------------------------------------- + +// ReplicaStatus + +// required fixed64 truncate_epoch = 1; +inline bool ReplicaStatus::has_truncate_epoch() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ReplicaStatus::set_has_truncate_epoch() { + _has_bits_[0] |= 0x00000001u; +} +inline void ReplicaStatus::clear_has_truncate_epoch() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ReplicaStatus::clear_truncate_epoch() { + truncate_epoch_ = GOOGLE_ULONGLONG(0); + clear_has_truncate_epoch(); +} +inline ::google::protobuf::uint64 ReplicaStatus::truncate_epoch() const { + return truncate_epoch_; +} +inline void ReplicaStatus::set_truncate_epoch(::google::protobuf::uint64 value) { + set_has_truncate_epoch(); + truncate_epoch_ = value; +} + +// required fixed64 file_size = 2; +inline bool ReplicaStatus::has_file_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ReplicaStatus::set_has_file_size() { + _has_bits_[0] |= 0x00000002u; +} +inline void ReplicaStatus::clear_has_file_size() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ReplicaStatus::clear_file_size() { + file_size_ = GOOGLE_ULONGLONG(0); + clear_has_file_size(); +} +inline ::google::protobuf::uint64 ReplicaStatus::file_size() const { + return file_size_; +} +inline void ReplicaStatus::set_file_size(::google::protobuf::uint64 value) { + set_has_file_size(); + file_size_ = value; +} + +// required fixed64 max_obj_version = 3; +inline bool ReplicaStatus::has_max_obj_version() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ReplicaStatus::set_has_max_obj_version() { + _has_bits_[0] |= 0x00000004u; +} +inline void ReplicaStatus::clear_has_max_obj_version() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ReplicaStatus::clear_max_obj_version() { + max_obj_version_ = GOOGLE_ULONGLONG(0); + clear_has_max_obj_version(); +} +inline ::google::protobuf::uint64 ReplicaStatus::max_obj_version() const { + return max_obj_version_; +} +inline void ReplicaStatus::set_max_obj_version(::google::protobuf::uint64 value) { + set_has_max_obj_version(); + max_obj_version_ = value; +} + +// required fixed32 primary_epoch = 4; +inline bool ReplicaStatus::has_primary_epoch() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ReplicaStatus::set_has_primary_epoch() { + _has_bits_[0] |= 0x00000008u; +} +inline void ReplicaStatus::clear_has_primary_epoch() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ReplicaStatus::clear_primary_epoch() { + primary_epoch_ = 0u; + clear_has_primary_epoch(); +} +inline ::google::protobuf::uint32 ReplicaStatus::primary_epoch() const { + return primary_epoch_; +} +inline void ReplicaStatus::set_primary_epoch(::google::protobuf::uint32 value) { + set_has_primary_epoch(); + primary_epoch_ = value; +} + +// repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5; +inline int ReplicaStatus::objectversions_size() const { + return objectversions_.size(); +} +inline void ReplicaStatus::clear_objectversions() { + objectversions_.Clear(); +} +inline const ::xtreemfs::pbrpc::ObjectVersion& ReplicaStatus::objectversions(int index) const { + return objectversions_.Get(index); +} +inline ::xtreemfs::pbrpc::ObjectVersion* ReplicaStatus::mutable_objectversions(int index) { + return objectversions_.Mutable(index); +} +inline ::xtreemfs::pbrpc::ObjectVersion* ReplicaStatus::add_objectversions() { + return objectversions_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersion >& +ReplicaStatus::objectversions() const { + return objectversions_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersion >* +ReplicaStatus::mutable_objectversions() { + return &objectversions_; +} + +// required .xtreemfs.pbrpc.TruncateLog truncate_log = 6; +inline bool ReplicaStatus::has_truncate_log() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ReplicaStatus::set_has_truncate_log() { + _has_bits_[0] |= 0x00000020u; +} +inline void ReplicaStatus::clear_has_truncate_log() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ReplicaStatus::clear_truncate_log() { + if (truncate_log_ != NULL) truncate_log_->::xtreemfs::pbrpc::TruncateLog::Clear(); + clear_has_truncate_log(); +} +inline const ::xtreemfs::pbrpc::TruncateLog& ReplicaStatus::truncate_log() const { + return truncate_log_ != NULL ? *truncate_log_ : *default_instance_->truncate_log_; +} +inline ::xtreemfs::pbrpc::TruncateLog* ReplicaStatus::mutable_truncate_log() { + set_has_truncate_log(); + if (truncate_log_ == NULL) truncate_log_ = new ::xtreemfs::pbrpc::TruncateLog; + return truncate_log_; +} +inline ::xtreemfs::pbrpc::TruncateLog* ReplicaStatus::release_truncate_log() { + clear_has_truncate_log(); + ::xtreemfs::pbrpc::TruncateLog* temp = truncate_log_; + truncate_log_ = NULL; + return temp; +} +inline void ReplicaStatus::set_allocated_truncate_log(::xtreemfs::pbrpc::TruncateLog* truncate_log) { + delete truncate_log_; + truncate_log_ = truncate_log; + if (truncate_log) { + set_has_truncate_log(); + } else { + clear_has_truncate_log(); + } +} + +// ------------------------------------------------------------------- + +// ObjectVersionMapping + +// required fixed64 object_number = 1; +inline bool ObjectVersionMapping::has_object_number() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ObjectVersionMapping::set_has_object_number() { + _has_bits_[0] |= 0x00000001u; +} +inline void ObjectVersionMapping::clear_has_object_number() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ObjectVersionMapping::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 ObjectVersionMapping::object_number() const { + return object_number_; +} +inline void ObjectVersionMapping::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 2; +inline bool ObjectVersionMapping::has_object_version() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ObjectVersionMapping::set_has_object_version() { + _has_bits_[0] |= 0x00000002u; +} +inline void ObjectVersionMapping::clear_has_object_version() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ObjectVersionMapping::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 ObjectVersionMapping::object_version() const { + return object_version_; +} +inline void ObjectVersionMapping::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// repeated string osd_uuids = 3; +inline int ObjectVersionMapping::osd_uuids_size() const { + return osd_uuids_.size(); +} +inline void ObjectVersionMapping::clear_osd_uuids() { + osd_uuids_.Clear(); +} +inline const ::std::string& ObjectVersionMapping::osd_uuids(int index) const { + return osd_uuids_.Get(index); +} +inline ::std::string* ObjectVersionMapping::mutable_osd_uuids(int index) { + return osd_uuids_.Mutable(index); +} +inline void ObjectVersionMapping::set_osd_uuids(int index, const ::std::string& value) { + osd_uuids_.Mutable(index)->assign(value); +} +inline void ObjectVersionMapping::set_osd_uuids(int index, const char* value) { + osd_uuids_.Mutable(index)->assign(value); +} +inline void ObjectVersionMapping::set_osd_uuids(int index, const char* value, size_t size) { + osd_uuids_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* ObjectVersionMapping::add_osd_uuids() { + return osd_uuids_.Add(); +} +inline void ObjectVersionMapping::add_osd_uuids(const ::std::string& value) { + osd_uuids_.Add()->assign(value); +} +inline void ObjectVersionMapping::add_osd_uuids(const char* value) { + osd_uuids_.Add()->assign(value); +} +inline void ObjectVersionMapping::add_osd_uuids(const char* value, size_t size) { + osd_uuids_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +ObjectVersionMapping::osd_uuids() const { + return osd_uuids_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +ObjectVersionMapping::mutable_osd_uuids() { + return &osd_uuids_; +} + +// ------------------------------------------------------------------- + +// AuthoritativeReplicaState + +// required fixed64 truncate_epoch = 1; +inline bool AuthoritativeReplicaState::has_truncate_epoch() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AuthoritativeReplicaState::set_has_truncate_epoch() { + _has_bits_[0] |= 0x00000001u; +} +inline void AuthoritativeReplicaState::clear_has_truncate_epoch() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AuthoritativeReplicaState::clear_truncate_epoch() { + truncate_epoch_ = GOOGLE_ULONGLONG(0); + clear_has_truncate_epoch(); +} +inline ::google::protobuf::uint64 AuthoritativeReplicaState::truncate_epoch() const { + return truncate_epoch_; +} +inline void AuthoritativeReplicaState::set_truncate_epoch(::google::protobuf::uint64 value) { + set_has_truncate_epoch(); + truncate_epoch_ = value; +} + +// required fixed64 max_obj_version = 4; +inline bool AuthoritativeReplicaState::has_max_obj_version() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AuthoritativeReplicaState::set_has_max_obj_version() { + _has_bits_[0] |= 0x00000002u; +} +inline void AuthoritativeReplicaState::clear_has_max_obj_version() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AuthoritativeReplicaState::clear_max_obj_version() { + max_obj_version_ = GOOGLE_ULONGLONG(0); + clear_has_max_obj_version(); +} +inline ::google::protobuf::uint64 AuthoritativeReplicaState::max_obj_version() const { + return max_obj_version_; +} +inline void AuthoritativeReplicaState::set_max_obj_version(::google::protobuf::uint64 value) { + set_has_max_obj_version(); + max_obj_version_ = value; +} + +// repeated .xtreemfs.pbrpc.ObjectVersionMapping objectVersions = 2; +inline int AuthoritativeReplicaState::objectversions_size() const { + return objectversions_.size(); +} +inline void AuthoritativeReplicaState::clear_objectversions() { + objectversions_.Clear(); +} +inline const ::xtreemfs::pbrpc::ObjectVersionMapping& AuthoritativeReplicaState::objectversions(int index) const { + return objectversions_.Get(index); +} +inline ::xtreemfs::pbrpc::ObjectVersionMapping* AuthoritativeReplicaState::mutable_objectversions(int index) { + return objectversions_.Mutable(index); +} +inline ::xtreemfs::pbrpc::ObjectVersionMapping* AuthoritativeReplicaState::add_objectversions() { + return objectversions_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersionMapping >& +AuthoritativeReplicaState::objectversions() const { + return objectversions_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectVersionMapping >* +AuthoritativeReplicaState::mutable_objectversions() { + return &objectversions_; +} + +// required .xtreemfs.pbrpc.TruncateLog truncate_log = 3; +inline bool AuthoritativeReplicaState::has_truncate_log() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void AuthoritativeReplicaState::set_has_truncate_log() { + _has_bits_[0] |= 0x00000008u; +} +inline void AuthoritativeReplicaState::clear_has_truncate_log() { + _has_bits_[0] &= ~0x00000008u; +} +inline void AuthoritativeReplicaState::clear_truncate_log() { + if (truncate_log_ != NULL) truncate_log_->::xtreemfs::pbrpc::TruncateLog::Clear(); + clear_has_truncate_log(); +} +inline const ::xtreemfs::pbrpc::TruncateLog& AuthoritativeReplicaState::truncate_log() const { + return truncate_log_ != NULL ? *truncate_log_ : *default_instance_->truncate_log_; +} +inline ::xtreemfs::pbrpc::TruncateLog* AuthoritativeReplicaState::mutable_truncate_log() { + set_has_truncate_log(); + if (truncate_log_ == NULL) truncate_log_ = new ::xtreemfs::pbrpc::TruncateLog; + return truncate_log_; +} +inline ::xtreemfs::pbrpc::TruncateLog* AuthoritativeReplicaState::release_truncate_log() { + clear_has_truncate_log(); + ::xtreemfs::pbrpc::TruncateLog* temp = truncate_log_; + truncate_log_ = NULL; + return temp; +} +inline void AuthoritativeReplicaState::set_allocated_truncate_log(::xtreemfs::pbrpc::TruncateLog* truncate_log) { + delete truncate_log_; + truncate_log_ = truncate_log; + if (truncate_log) { + set_has_truncate_log(); + } else { + clear_has_truncate_log(); + } +} + +// ------------------------------------------------------------------- + +// InternalReadLocalResponse + +// required .xtreemfs.pbrpc.ObjectData data = 1; +inline bool InternalReadLocalResponse::has_data() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void InternalReadLocalResponse::set_has_data() { + _has_bits_[0] |= 0x00000001u; +} +inline void InternalReadLocalResponse::clear_has_data() { + _has_bits_[0] &= ~0x00000001u; +} +inline void InternalReadLocalResponse::clear_data() { + if (data_ != NULL) data_->::xtreemfs::pbrpc::ObjectData::Clear(); + clear_has_data(); +} +inline const ::xtreemfs::pbrpc::ObjectData& InternalReadLocalResponse::data() const { + return data_ != NULL ? *data_ : *default_instance_->data_; +} +inline ::xtreemfs::pbrpc::ObjectData* InternalReadLocalResponse::mutable_data() { + set_has_data(); + if (data_ == NULL) data_ = new ::xtreemfs::pbrpc::ObjectData; + return data_; +} +inline ::xtreemfs::pbrpc::ObjectData* InternalReadLocalResponse::release_data() { + clear_has_data(); + ::xtreemfs::pbrpc::ObjectData* temp = data_; + data_ = NULL; + return temp; +} +inline void InternalReadLocalResponse::set_allocated_data(::xtreemfs::pbrpc::ObjectData* data) { + delete data_; + data_ = data; + if (data) { + set_has_data(); + } else { + clear_has_data(); + } +} + +// repeated .xtreemfs.pbrpc.ObjectList object_set = 2; +inline int InternalReadLocalResponse::object_set_size() const { + return object_set_.size(); +} +inline void InternalReadLocalResponse::clear_object_set() { + object_set_.Clear(); +} +inline const ::xtreemfs::pbrpc::ObjectList& InternalReadLocalResponse::object_set(int index) const { + return object_set_.Get(index); +} +inline ::xtreemfs::pbrpc::ObjectList* InternalReadLocalResponse::mutable_object_set(int index) { + return object_set_.Mutable(index); +} +inline ::xtreemfs::pbrpc::ObjectList* InternalReadLocalResponse::add_object_set() { + return object_set_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList >& +InternalReadLocalResponse::object_set() const { + return object_set_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList >* +InternalReadLocalResponse::mutable_object_set() { + return &object_set_; +} + +// ------------------------------------------------------------------- + +// readRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool readRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void readRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void readRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void readRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& readRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* readRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* readRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void readRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool readRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void readRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void readRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void readRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& readRequest::file_id() const { + return *file_id_; +} +inline void readRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void readRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void readRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* readRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* readRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void readRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 object_number = 3; +inline bool readRequest::has_object_number() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void readRequest::set_has_object_number() { + _has_bits_[0] |= 0x00000004u; +} +inline void readRequest::clear_has_object_number() { + _has_bits_[0] &= ~0x00000004u; +} +inline void readRequest::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 readRequest::object_number() const { + return object_number_; +} +inline void readRequest::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 4; +inline bool readRequest::has_object_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void readRequest::set_has_object_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void readRequest::clear_has_object_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void readRequest::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 readRequest::object_version() const { + return object_version_; +} +inline void readRequest::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// required fixed32 offset = 5; +inline bool readRequest::has_offset() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void readRequest::set_has_offset() { + _has_bits_[0] |= 0x00000010u; +} +inline void readRequest::clear_has_offset() { + _has_bits_[0] &= ~0x00000010u; +} +inline void readRequest::clear_offset() { + offset_ = 0u; + clear_has_offset(); +} +inline ::google::protobuf::uint32 readRequest::offset() const { + return offset_; +} +inline void readRequest::set_offset(::google::protobuf::uint32 value) { + set_has_offset(); + offset_ = value; +} + +// required fixed32 length = 6; +inline bool readRequest::has_length() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void readRequest::set_has_length() { + _has_bits_[0] |= 0x00000020u; +} +inline void readRequest::clear_has_length() { + _has_bits_[0] &= ~0x00000020u; +} +inline void readRequest::clear_length() { + length_ = 0u; + clear_has_length(); +} +inline ::google::protobuf::uint32 readRequest::length() const { + return length_; +} +inline void readRequest::set_length(::google::protobuf::uint32 value) { + set_has_length(); + length_ = value; +} + +// ------------------------------------------------------------------- + +// truncateRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool truncateRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void truncateRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void truncateRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void truncateRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& truncateRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* truncateRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* truncateRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void truncateRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool truncateRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void truncateRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void truncateRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void truncateRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& truncateRequest::file_id() const { + return *file_id_; +} +inline void truncateRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void truncateRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void truncateRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* truncateRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* truncateRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void truncateRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 new_file_size = 3; +inline bool truncateRequest::has_new_file_size() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void truncateRequest::set_has_new_file_size() { + _has_bits_[0] |= 0x00000004u; +} +inline void truncateRequest::clear_has_new_file_size() { + _has_bits_[0] &= ~0x00000004u; +} +inline void truncateRequest::clear_new_file_size() { + new_file_size_ = GOOGLE_ULONGLONG(0); + clear_has_new_file_size(); +} +inline ::google::protobuf::uint64 truncateRequest::new_file_size() const { + return new_file_size_; +} +inline void truncateRequest::set_new_file_size(::google::protobuf::uint64 value) { + set_has_new_file_size(); + new_file_size_ = value; +} + +// ------------------------------------------------------------------- + +// unlink_osd_Request + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool unlink_osd_Request::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void unlink_osd_Request::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void unlink_osd_Request::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void unlink_osd_Request::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& unlink_osd_Request::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* unlink_osd_Request::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* unlink_osd_Request::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void unlink_osd_Request::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool unlink_osd_Request::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void unlink_osd_Request::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void unlink_osd_Request::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void unlink_osd_Request::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& unlink_osd_Request::file_id() const { + return *file_id_; +} +inline void unlink_osd_Request::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void unlink_osd_Request::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void unlink_osd_Request::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* unlink_osd_Request::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* unlink_osd_Request::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void unlink_osd_Request::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// writeRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool writeRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void writeRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void writeRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void writeRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& writeRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* writeRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* writeRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void writeRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool writeRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void writeRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void writeRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void writeRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& writeRequest::file_id() const { + return *file_id_; +} +inline void writeRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void writeRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void writeRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* writeRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* writeRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void writeRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 object_number = 3; +inline bool writeRequest::has_object_number() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void writeRequest::set_has_object_number() { + _has_bits_[0] |= 0x00000004u; +} +inline void writeRequest::clear_has_object_number() { + _has_bits_[0] &= ~0x00000004u; +} +inline void writeRequest::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 writeRequest::object_number() const { + return object_number_; +} +inline void writeRequest::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 4; +inline bool writeRequest::has_object_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void writeRequest::set_has_object_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void writeRequest::clear_has_object_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void writeRequest::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 writeRequest::object_version() const { + return object_version_; +} +inline void writeRequest::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// required fixed32 offset = 5; +inline bool writeRequest::has_offset() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void writeRequest::set_has_offset() { + _has_bits_[0] |= 0x00000010u; +} +inline void writeRequest::clear_has_offset() { + _has_bits_[0] &= ~0x00000010u; +} +inline void writeRequest::clear_offset() { + offset_ = 0u; + clear_has_offset(); +} +inline ::google::protobuf::uint32 writeRequest::offset() const { + return offset_; +} +inline void writeRequest::set_offset(::google::protobuf::uint32 value) { + set_has_offset(); + offset_ = value; +} + +// required fixed64 lease_timeout = 6; +inline bool writeRequest::has_lease_timeout() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void writeRequest::set_has_lease_timeout() { + _has_bits_[0] |= 0x00000020u; +} +inline void writeRequest::clear_has_lease_timeout() { + _has_bits_[0] &= ~0x00000020u; +} +inline void writeRequest::clear_lease_timeout() { + lease_timeout_ = GOOGLE_ULONGLONG(0); + clear_has_lease_timeout(); +} +inline ::google::protobuf::uint64 writeRequest::lease_timeout() const { + return lease_timeout_; +} +inline void writeRequest::set_lease_timeout(::google::protobuf::uint64 value) { + set_has_lease_timeout(); + lease_timeout_ = value; +} + +// required .xtreemfs.pbrpc.ObjectData object_data = 7; +inline bool writeRequest::has_object_data() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void writeRequest::set_has_object_data() { + _has_bits_[0] |= 0x00000040u; +} +inline void writeRequest::clear_has_object_data() { + _has_bits_[0] &= ~0x00000040u; +} +inline void writeRequest::clear_object_data() { + if (object_data_ != NULL) object_data_->::xtreemfs::pbrpc::ObjectData::Clear(); + clear_has_object_data(); +} +inline const ::xtreemfs::pbrpc::ObjectData& writeRequest::object_data() const { + return object_data_ != NULL ? *object_data_ : *default_instance_->object_data_; +} +inline ::xtreemfs::pbrpc::ObjectData* writeRequest::mutable_object_data() { + set_has_object_data(); + if (object_data_ == NULL) object_data_ = new ::xtreemfs::pbrpc::ObjectData; + return object_data_; +} +inline ::xtreemfs::pbrpc::ObjectData* writeRequest::release_object_data() { + clear_has_object_data(); + ::xtreemfs::pbrpc::ObjectData* temp = object_data_; + object_data_ = NULL; + return temp; +} +inline void writeRequest::set_allocated_object_data(::xtreemfs::pbrpc::ObjectData* object_data) { + delete object_data_; + object_data_ = object_data; + if (object_data) { + set_has_object_data(); + } else { + clear_has_object_data(); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_broadcast_gmaxRequest + +// required string file_id = 1; +inline bool xtreemfs_broadcast_gmaxRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_broadcast_gmaxRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_broadcast_gmaxRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_broadcast_gmaxRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_broadcast_gmaxRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_broadcast_gmaxRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_broadcast_gmaxRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_broadcast_gmaxRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_broadcast_gmaxRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_broadcast_gmaxRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_broadcast_gmaxRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 truncate_epoch = 2; +inline bool xtreemfs_broadcast_gmaxRequest::has_truncate_epoch() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_broadcast_gmaxRequest::set_has_truncate_epoch() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_broadcast_gmaxRequest::clear_has_truncate_epoch() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_broadcast_gmaxRequest::clear_truncate_epoch() { + truncate_epoch_ = GOOGLE_ULONGLONG(0); + clear_has_truncate_epoch(); +} +inline ::google::protobuf::uint64 xtreemfs_broadcast_gmaxRequest::truncate_epoch() const { + return truncate_epoch_; +} +inline void xtreemfs_broadcast_gmaxRequest::set_truncate_epoch(::google::protobuf::uint64 value) { + set_has_truncate_epoch(); + truncate_epoch_ = value; +} + +// required fixed64 last_object = 3; +inline bool xtreemfs_broadcast_gmaxRequest::has_last_object() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_broadcast_gmaxRequest::set_has_last_object() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_broadcast_gmaxRequest::clear_has_last_object() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_broadcast_gmaxRequest::clear_last_object() { + last_object_ = GOOGLE_ULONGLONG(0); + clear_has_last_object(); +} +inline ::google::protobuf::uint64 xtreemfs_broadcast_gmaxRequest::last_object() const { + return last_object_; +} +inline void xtreemfs_broadcast_gmaxRequest::set_last_object(::google::protobuf::uint64 value) { + set_has_last_object(); + last_object_ = value; +} + +// required fixed64 file_size = 4; +inline bool xtreemfs_broadcast_gmaxRequest::has_file_size() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_broadcast_gmaxRequest::set_has_file_size() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_broadcast_gmaxRequest::clear_has_file_size() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_broadcast_gmaxRequest::clear_file_size() { + file_size_ = GOOGLE_ULONGLONG(0); + clear_has_file_size(); +} +inline ::google::protobuf::uint64 xtreemfs_broadcast_gmaxRequest::file_size() const { + return file_size_; +} +inline void xtreemfs_broadcast_gmaxRequest::set_file_size(::google::protobuf::uint64 value) { + set_has_file_size(); + file_size_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_check_objectRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_check_objectRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_check_objectRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_check_objectRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_check_objectRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_check_objectRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_check_objectRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_check_objectRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_check_objectRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_check_objectRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_check_objectRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_check_objectRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_check_objectRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_check_objectRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_check_objectRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_check_objectRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_check_objectRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_check_objectRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_check_objectRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_check_objectRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 object_number = 3; +inline bool xtreemfs_check_objectRequest::has_object_number() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_check_objectRequest::set_has_object_number() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_check_objectRequest::clear_has_object_number() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_check_objectRequest::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 xtreemfs_check_objectRequest::object_number() const { + return object_number_; +} +inline void xtreemfs_check_objectRequest::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 4; +inline bool xtreemfs_check_objectRequest::has_object_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_check_objectRequest::set_has_object_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_check_objectRequest::clear_has_object_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_check_objectRequest::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 xtreemfs_check_objectRequest::object_version() const { + return object_version_; +} +inline void xtreemfs_check_objectRequest::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_cleanup_get_resultsResponse + +// repeated string results = 1; +inline int xtreemfs_cleanup_get_resultsResponse::results_size() const { + return results_.size(); +} +inline void xtreemfs_cleanup_get_resultsResponse::clear_results() { + results_.Clear(); +} +inline const ::std::string& xtreemfs_cleanup_get_resultsResponse::results(int index) const { + return results_.Get(index); +} +inline ::std::string* xtreemfs_cleanup_get_resultsResponse::mutable_results(int index) { + return results_.Mutable(index); +} +inline void xtreemfs_cleanup_get_resultsResponse::set_results(int index, const ::std::string& value) { + results_.Mutable(index)->assign(value); +} +inline void xtreemfs_cleanup_get_resultsResponse::set_results(int index, const char* value) { + results_.Mutable(index)->assign(value); +} +inline void xtreemfs_cleanup_get_resultsResponse::set_results(int index, const char* value, size_t size) { + results_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_cleanup_get_resultsResponse::add_results() { + return results_.Add(); +} +inline void xtreemfs_cleanup_get_resultsResponse::add_results(const ::std::string& value) { + results_.Add()->assign(value); +} +inline void xtreemfs_cleanup_get_resultsResponse::add_results(const char* value) { + results_.Add()->assign(value); +} +inline void xtreemfs_cleanup_get_resultsResponse::add_results(const char* value, size_t size) { + results_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +xtreemfs_cleanup_get_resultsResponse::results() const { + return results_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +xtreemfs_cleanup_get_resultsResponse::mutable_results() { + return &results_; +} + +// ------------------------------------------------------------------- + +// xtreemfs_cleanup_is_runningResponse + +// required bool is_running = 1; +inline bool xtreemfs_cleanup_is_runningResponse::has_is_running() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_cleanup_is_runningResponse::set_has_is_running() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_cleanup_is_runningResponse::clear_has_is_running() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_cleanup_is_runningResponse::clear_is_running() { + is_running_ = false; + clear_has_is_running(); +} +inline bool xtreemfs_cleanup_is_runningResponse::is_running() const { + return is_running_; +} +inline void xtreemfs_cleanup_is_runningResponse::set_is_running(bool value) { + set_has_is_running(); + is_running_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_cleanup_startRequest + +// required bool remove_zombies = 1; +inline bool xtreemfs_cleanup_startRequest::has_remove_zombies() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_cleanup_startRequest::set_has_remove_zombies() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_cleanup_startRequest::clear_has_remove_zombies() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_cleanup_startRequest::clear_remove_zombies() { + remove_zombies_ = false; + clear_has_remove_zombies(); +} +inline bool xtreemfs_cleanup_startRequest::remove_zombies() const { + return remove_zombies_; +} +inline void xtreemfs_cleanup_startRequest::set_remove_zombies(bool value) { + set_has_remove_zombies(); + remove_zombies_ = value; +} + +// required bool remove_unavail_volume = 2; +inline bool xtreemfs_cleanup_startRequest::has_remove_unavail_volume() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_cleanup_startRequest::set_has_remove_unavail_volume() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_cleanup_startRequest::clear_has_remove_unavail_volume() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_cleanup_startRequest::clear_remove_unavail_volume() { + remove_unavail_volume_ = false; + clear_has_remove_unavail_volume(); +} +inline bool xtreemfs_cleanup_startRequest::remove_unavail_volume() const { + return remove_unavail_volume_; +} +inline void xtreemfs_cleanup_startRequest::set_remove_unavail_volume(bool value) { + set_has_remove_unavail_volume(); + remove_unavail_volume_ = value; +} + +// required bool lost_and_found = 3; +inline bool xtreemfs_cleanup_startRequest::has_lost_and_found() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_cleanup_startRequest::set_has_lost_and_found() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_cleanup_startRequest::clear_has_lost_and_found() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_cleanup_startRequest::clear_lost_and_found() { + lost_and_found_ = false; + clear_has_lost_and_found(); +} +inline bool xtreemfs_cleanup_startRequest::lost_and_found() const { + return lost_and_found_; +} +inline void xtreemfs_cleanup_startRequest::set_lost_and_found(bool value) { + set_has_lost_and_found(); + lost_and_found_ = value; +} + +// required bool delete_metadata = 4; +inline bool xtreemfs_cleanup_startRequest::has_delete_metadata() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_cleanup_startRequest::set_has_delete_metadata() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_cleanup_startRequest::clear_has_delete_metadata() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_cleanup_startRequest::clear_delete_metadata() { + delete_metadata_ = false; + clear_has_delete_metadata(); +} +inline bool xtreemfs_cleanup_startRequest::delete_metadata() const { + return delete_metadata_; +} +inline void xtreemfs_cleanup_startRequest::set_delete_metadata(bool value) { + set_has_delete_metadata(); + delete_metadata_ = value; +} + +// required fixed32 metadata_timeout = 5; +inline bool xtreemfs_cleanup_startRequest::has_metadata_timeout() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void xtreemfs_cleanup_startRequest::set_has_metadata_timeout() { + _has_bits_[0] |= 0x00000010u; +} +inline void xtreemfs_cleanup_startRequest::clear_has_metadata_timeout() { + _has_bits_[0] &= ~0x00000010u; +} +inline void xtreemfs_cleanup_startRequest::clear_metadata_timeout() { + metadata_timeout_ = 0u; + clear_has_metadata_timeout(); +} +inline ::google::protobuf::uint32 xtreemfs_cleanup_startRequest::metadata_timeout() const { + return metadata_timeout_; +} +inline void xtreemfs_cleanup_startRequest::set_metadata_timeout(::google::protobuf::uint32 value) { + set_has_metadata_timeout(); + metadata_timeout_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_cleanup_statusResponse + +// required string status = 1; +inline bool xtreemfs_cleanup_statusResponse::has_status() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_cleanup_statusResponse::set_has_status() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_cleanup_statusResponse::clear_has_status() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_cleanup_statusResponse::clear_status() { + if (status_ != &::google::protobuf::internal::kEmptyString) { + status_->clear(); + } + clear_has_status(); +} +inline const ::std::string& xtreemfs_cleanup_statusResponse::status() const { + return *status_; +} +inline void xtreemfs_cleanup_statusResponse::set_status(const ::std::string& value) { + set_has_status(); + if (status_ == &::google::protobuf::internal::kEmptyString) { + status_ = new ::std::string; + } + status_->assign(value); +} +inline void xtreemfs_cleanup_statusResponse::set_status(const char* value) { + set_has_status(); + if (status_ == &::google::protobuf::internal::kEmptyString) { + status_ = new ::std::string; + } + status_->assign(value); +} +inline void xtreemfs_cleanup_statusResponse::set_status(const char* value, size_t size) { + set_has_status(); + if (status_ == &::google::protobuf::internal::kEmptyString) { + status_ = new ::std::string; + } + status_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_cleanup_statusResponse::mutable_status() { + set_has_status(); + if (status_ == &::google::protobuf::internal::kEmptyString) { + status_ = new ::std::string; + } + return status_; +} +inline ::std::string* xtreemfs_cleanup_statusResponse::release_status() { + clear_has_status(); + if (status_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = status_; + status_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_cleanup_statusResponse::set_allocated_status(::std::string* status) { + if (status_ != &::google::protobuf::internal::kEmptyString) { + delete status_; + } + if (status) { + set_has_status(); + status_ = status; + } else { + clear_has_status(); + status_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_rwr_fetchRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_rwr_fetchRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rwr_fetchRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rwr_fetchRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rwr_fetchRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_rwr_fetchRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_fetchRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_fetchRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_rwr_fetchRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_rwr_fetchRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_rwr_fetchRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_rwr_fetchRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_rwr_fetchRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_rwr_fetchRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_rwr_fetchRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_fetchRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_fetchRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rwr_fetchRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_rwr_fetchRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rwr_fetchRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 object_number = 3; +inline bool xtreemfs_rwr_fetchRequest::has_object_number() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_rwr_fetchRequest::set_has_object_number() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_rwr_fetchRequest::clear_has_object_number() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_rwr_fetchRequest::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 xtreemfs_rwr_fetchRequest::object_number() const { + return object_number_; +} +inline void xtreemfs_rwr_fetchRequest::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 4; +inline bool xtreemfs_rwr_fetchRequest::has_object_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_rwr_fetchRequest::set_has_object_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_rwr_fetchRequest::clear_has_object_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_rwr_fetchRequest::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 xtreemfs_rwr_fetchRequest::object_version() const { + return object_version_; +} +inline void xtreemfs_rwr_fetchRequest::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_repair_objectRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_repair_objectRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_repair_objectRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_repair_objectRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_repair_objectRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_repair_objectRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_repair_objectRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_repair_objectRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_repair_objectRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_repair_objectRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_repair_objectRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_repair_objectRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_repair_objectRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_repair_objectRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_repair_objectRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_repair_objectRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_repair_objectRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_repair_objectRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_repair_objectRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_repair_objectRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 object_number = 3; +inline bool xtreemfs_repair_objectRequest::has_object_number() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_repair_objectRequest::set_has_object_number() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_repair_objectRequest::clear_has_object_number() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_repair_objectRequest::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 xtreemfs_repair_objectRequest::object_number() const { + return object_number_; +} +inline void xtreemfs_repair_objectRequest::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 4; +inline bool xtreemfs_repair_objectRequest::has_object_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_repair_objectRequest::set_has_object_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_repair_objectRequest::clear_has_object_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_repair_objectRequest::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 xtreemfs_repair_objectRequest::object_version() const { + return object_version_; +} +inline void xtreemfs_repair_objectRequest::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_rwr_flease_msgRequest + +// required string sender_hostname = 1; +inline bool xtreemfs_rwr_flease_msgRequest::has_sender_hostname() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rwr_flease_msgRequest::set_has_sender_hostname() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rwr_flease_msgRequest::clear_has_sender_hostname() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rwr_flease_msgRequest::clear_sender_hostname() { + if (sender_hostname_ != &::google::protobuf::internal::kEmptyString) { + sender_hostname_->clear(); + } + clear_has_sender_hostname(); +} +inline const ::std::string& xtreemfs_rwr_flease_msgRequest::sender_hostname() const { + return *sender_hostname_; +} +inline void xtreemfs_rwr_flease_msgRequest::set_sender_hostname(const ::std::string& value) { + set_has_sender_hostname(); + if (sender_hostname_ == &::google::protobuf::internal::kEmptyString) { + sender_hostname_ = new ::std::string; + } + sender_hostname_->assign(value); +} +inline void xtreemfs_rwr_flease_msgRequest::set_sender_hostname(const char* value) { + set_has_sender_hostname(); + if (sender_hostname_ == &::google::protobuf::internal::kEmptyString) { + sender_hostname_ = new ::std::string; + } + sender_hostname_->assign(value); +} +inline void xtreemfs_rwr_flease_msgRequest::set_sender_hostname(const char* value, size_t size) { + set_has_sender_hostname(); + if (sender_hostname_ == &::google::protobuf::internal::kEmptyString) { + sender_hostname_ = new ::std::string; + } + sender_hostname_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rwr_flease_msgRequest::mutable_sender_hostname() { + set_has_sender_hostname(); + if (sender_hostname_ == &::google::protobuf::internal::kEmptyString) { + sender_hostname_ = new ::std::string; + } + return sender_hostname_; +} +inline ::std::string* xtreemfs_rwr_flease_msgRequest::release_sender_hostname() { + clear_has_sender_hostname(); + if (sender_hostname_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = sender_hostname_; + sender_hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rwr_flease_msgRequest::set_allocated_sender_hostname(::std::string* sender_hostname) { + if (sender_hostname_ != &::google::protobuf::internal::kEmptyString) { + delete sender_hostname_; + } + if (sender_hostname) { + set_has_sender_hostname(); + sender_hostname_ = sender_hostname; + } else { + clear_has_sender_hostname(); + sender_hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 sender_port = 2; +inline bool xtreemfs_rwr_flease_msgRequest::has_sender_port() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_rwr_flease_msgRequest::set_has_sender_port() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_rwr_flease_msgRequest::clear_has_sender_port() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_rwr_flease_msgRequest::clear_sender_port() { + sender_port_ = 0u; + clear_has_sender_port(); +} +inline ::google::protobuf::uint32 xtreemfs_rwr_flease_msgRequest::sender_port() const { + return sender_port_; +} +inline void xtreemfs_rwr_flease_msgRequest::set_sender_port(::google::protobuf::uint32 value) { + set_has_sender_port(); + sender_port_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_rwr_set_primary_epochRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_rwr_set_primary_epochRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rwr_set_primary_epochRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rwr_set_primary_epochRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_rwr_set_primary_epochRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_set_primary_epochRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_set_primary_epochRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_rwr_set_primary_epochRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_rwr_set_primary_epochRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_rwr_set_primary_epochRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_rwr_set_primary_epochRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rwr_set_primary_epochRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_rwr_set_primary_epochRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 primary_epoch = 3; +inline bool xtreemfs_rwr_set_primary_epochRequest::has_primary_epoch() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_has_primary_epoch() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_rwr_set_primary_epochRequest::clear_has_primary_epoch() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_rwr_set_primary_epochRequest::clear_primary_epoch() { + primary_epoch_ = 0u; + clear_has_primary_epoch(); +} +inline ::google::protobuf::uint32 xtreemfs_rwr_set_primary_epochRequest::primary_epoch() const { + return primary_epoch_; +} +inline void xtreemfs_rwr_set_primary_epochRequest::set_primary_epoch(::google::protobuf::uint32 value) { + set_has_primary_epoch(); + primary_epoch_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_rwr_statusRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_rwr_statusRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rwr_statusRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rwr_statusRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rwr_statusRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_rwr_statusRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_statusRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_statusRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_rwr_statusRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_rwr_statusRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_rwr_statusRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_rwr_statusRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_rwr_statusRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_rwr_statusRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_rwr_statusRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_statusRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_statusRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rwr_statusRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_rwr_statusRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rwr_statusRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 max_local_obj_version = 3; +inline bool xtreemfs_rwr_statusRequest::has_max_local_obj_version() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_rwr_statusRequest::set_has_max_local_obj_version() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_rwr_statusRequest::clear_has_max_local_obj_version() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_rwr_statusRequest::clear_max_local_obj_version() { + max_local_obj_version_ = GOOGLE_ULONGLONG(0); + clear_has_max_local_obj_version(); +} +inline ::google::protobuf::uint64 xtreemfs_rwr_statusRequest::max_local_obj_version() const { + return max_local_obj_version_; +} +inline void xtreemfs_rwr_statusRequest::set_max_local_obj_version(::google::protobuf::uint64 value) { + set_has_max_local_obj_version(); + max_local_obj_version_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_rwr_truncateRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_rwr_truncateRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rwr_truncateRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rwr_truncateRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rwr_truncateRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_rwr_truncateRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_truncateRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_truncateRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_rwr_truncateRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_rwr_truncateRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_rwr_truncateRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_rwr_truncateRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_rwr_truncateRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_rwr_truncateRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_rwr_truncateRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_truncateRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_truncateRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rwr_truncateRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_rwr_truncateRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rwr_truncateRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 new_file_size = 3; +inline bool xtreemfs_rwr_truncateRequest::has_new_file_size() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_rwr_truncateRequest::set_has_new_file_size() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_rwr_truncateRequest::clear_has_new_file_size() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_rwr_truncateRequest::clear_new_file_size() { + new_file_size_ = GOOGLE_ULONGLONG(0); + clear_has_new_file_size(); +} +inline ::google::protobuf::uint64 xtreemfs_rwr_truncateRequest::new_file_size() const { + return new_file_size_; +} +inline void xtreemfs_rwr_truncateRequest::set_new_file_size(::google::protobuf::uint64 value) { + set_has_new_file_size(); + new_file_size_ = value; +} + +// required fixed64 object_version = 4; +inline bool xtreemfs_rwr_truncateRequest::has_object_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_rwr_truncateRequest::set_has_object_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_rwr_truncateRequest::clear_has_object_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_rwr_truncateRequest::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 xtreemfs_rwr_truncateRequest::object_version() const { + return object_version_; +} +inline void xtreemfs_rwr_truncateRequest::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_rwr_updateRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_rwr_updateRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rwr_updateRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rwr_updateRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rwr_updateRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_rwr_updateRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_updateRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_updateRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_rwr_updateRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_rwr_updateRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_rwr_updateRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_rwr_updateRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_rwr_updateRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_rwr_updateRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_rwr_updateRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_updateRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_updateRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rwr_updateRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_rwr_updateRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rwr_updateRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 new_file_size = 3; +inline bool xtreemfs_rwr_updateRequest::has_new_file_size() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_rwr_updateRequest::set_has_new_file_size() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_rwr_updateRequest::clear_has_new_file_size() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_rwr_updateRequest::clear_new_file_size() { + new_file_size_ = GOOGLE_ULONGLONG(0); + clear_has_new_file_size(); +} +inline ::google::protobuf::uint64 xtreemfs_rwr_updateRequest::new_file_size() const { + return new_file_size_; +} +inline void xtreemfs_rwr_updateRequest::set_new_file_size(::google::protobuf::uint64 value) { + set_has_new_file_size(); + new_file_size_ = value; +} + +// required fixed64 object_number = 7; +inline bool xtreemfs_rwr_updateRequest::has_object_number() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_rwr_updateRequest::set_has_object_number() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_rwr_updateRequest::clear_has_object_number() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_rwr_updateRequest::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 xtreemfs_rwr_updateRequest::object_number() const { + return object_number_; +} +inline void xtreemfs_rwr_updateRequest::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 4; +inline bool xtreemfs_rwr_updateRequest::has_object_version() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void xtreemfs_rwr_updateRequest::set_has_object_version() { + _has_bits_[0] |= 0x00000010u; +} +inline void xtreemfs_rwr_updateRequest::clear_has_object_version() { + _has_bits_[0] &= ~0x00000010u; +} +inline void xtreemfs_rwr_updateRequest::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 xtreemfs_rwr_updateRequest::object_version() const { + return object_version_; +} +inline void xtreemfs_rwr_updateRequest::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// required fixed32 offset = 5; +inline bool xtreemfs_rwr_updateRequest::has_offset() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void xtreemfs_rwr_updateRequest::set_has_offset() { + _has_bits_[0] |= 0x00000020u; +} +inline void xtreemfs_rwr_updateRequest::clear_has_offset() { + _has_bits_[0] &= ~0x00000020u; +} +inline void xtreemfs_rwr_updateRequest::clear_offset() { + offset_ = 0u; + clear_has_offset(); +} +inline ::google::protobuf::uint32 xtreemfs_rwr_updateRequest::offset() const { + return offset_; +} +inline void xtreemfs_rwr_updateRequest::set_offset(::google::protobuf::uint32 value) { + set_has_offset(); + offset_ = value; +} + +// required .xtreemfs.pbrpc.ObjectData obj = 6; +inline bool xtreemfs_rwr_updateRequest::has_obj() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void xtreemfs_rwr_updateRequest::set_has_obj() { + _has_bits_[0] |= 0x00000040u; +} +inline void xtreemfs_rwr_updateRequest::clear_has_obj() { + _has_bits_[0] &= ~0x00000040u; +} +inline void xtreemfs_rwr_updateRequest::clear_obj() { + if (obj_ != NULL) obj_->::xtreemfs::pbrpc::ObjectData::Clear(); + clear_has_obj(); +} +inline const ::xtreemfs::pbrpc::ObjectData& xtreemfs_rwr_updateRequest::obj() const { + return obj_ != NULL ? *obj_ : *default_instance_->obj_; +} +inline ::xtreemfs::pbrpc::ObjectData* xtreemfs_rwr_updateRequest::mutable_obj() { + set_has_obj(); + if (obj_ == NULL) obj_ = new ::xtreemfs::pbrpc::ObjectData; + return obj_; +} +inline ::xtreemfs::pbrpc::ObjectData* xtreemfs_rwr_updateRequest::release_obj() { + clear_has_obj(); + ::xtreemfs::pbrpc::ObjectData* temp = obj_; + obj_ = NULL; + return temp; +} +inline void xtreemfs_rwr_updateRequest::set_allocated_obj(::xtreemfs::pbrpc::ObjectData* obj) { + delete obj_; + obj_ = obj; + if (obj) { + set_has_obj(); + } else { + clear_has_obj(); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_internal_get_gmaxRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_internal_get_gmaxRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_internal_get_gmaxRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_internal_get_gmaxRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_internal_get_gmaxRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_internal_get_gmaxRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_internal_get_gmaxRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_internal_get_gmaxRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_internal_get_gmaxRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_internal_get_gmaxRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_internal_get_gmaxRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_internal_get_gmaxRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_internal_get_gmaxRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_internal_get_gmaxRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_internal_get_gmaxRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_internal_get_gmaxRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_internal_get_gmaxRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_internal_get_gmaxRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_internal_get_gmaxRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_internal_get_gmaxRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_internal_get_file_sizeRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_internal_get_file_sizeRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_internal_get_file_sizeRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_internal_get_file_sizeRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_internal_get_file_sizeRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_internal_get_file_sizeRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_internal_get_file_sizeRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_internal_get_file_sizeRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_internal_get_file_sizeRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_internal_get_file_sizeRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_internal_get_file_sizeRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_internal_get_file_sizeRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_internal_get_file_sizeRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_internal_get_file_sizeRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_internal_get_file_sizeRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_internal_get_file_sizeRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_internal_get_file_sizeRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_internal_get_file_sizeRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_internal_get_file_sizeRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_internal_get_file_sizeRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_internal_get_file_sizeResponse + +// required fixed64 file_size = 1; +inline bool xtreemfs_internal_get_file_sizeResponse::has_file_size() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_internal_get_file_sizeResponse::set_has_file_size() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_internal_get_file_sizeResponse::clear_has_file_size() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_internal_get_file_sizeResponse::clear_file_size() { + file_size_ = GOOGLE_ULONGLONG(0); + clear_has_file_size(); +} +inline ::google::protobuf::uint64 xtreemfs_internal_get_file_sizeResponse::file_size() const { + return file_size_; +} +inline void xtreemfs_internal_get_file_sizeResponse::set_file_size(::google::protobuf::uint64 value) { + set_has_file_size(); + file_size_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_internal_read_localRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_internal_read_localRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_internal_read_localRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_internal_read_localRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_internal_read_localRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_internal_read_localRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_internal_read_localRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_internal_read_localRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_internal_read_localRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_internal_read_localRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_internal_read_localRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_internal_read_localRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_internal_read_localRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_internal_read_localRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_internal_read_localRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_internal_read_localRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_internal_read_localRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_internal_read_localRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_internal_read_localRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_internal_read_localRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed64 object_number = 3; +inline bool xtreemfs_internal_read_localRequest::has_object_number() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_internal_read_localRequest::set_has_object_number() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_internal_read_localRequest::clear_has_object_number() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_internal_read_localRequest::clear_object_number() { + object_number_ = GOOGLE_ULONGLONG(0); + clear_has_object_number(); +} +inline ::google::protobuf::uint64 xtreemfs_internal_read_localRequest::object_number() const { + return object_number_; +} +inline void xtreemfs_internal_read_localRequest::set_object_number(::google::protobuf::uint64 value) { + set_has_object_number(); + object_number_ = value; +} + +// required fixed64 object_version = 4; +inline bool xtreemfs_internal_read_localRequest::has_object_version() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void xtreemfs_internal_read_localRequest::set_has_object_version() { + _has_bits_[0] |= 0x00000008u; +} +inline void xtreemfs_internal_read_localRequest::clear_has_object_version() { + _has_bits_[0] &= ~0x00000008u; +} +inline void xtreemfs_internal_read_localRequest::clear_object_version() { + object_version_ = GOOGLE_ULONGLONG(0); + clear_has_object_version(); +} +inline ::google::protobuf::uint64 xtreemfs_internal_read_localRequest::object_version() const { + return object_version_; +} +inline void xtreemfs_internal_read_localRequest::set_object_version(::google::protobuf::uint64 value) { + set_has_object_version(); + object_version_ = value; +} + +// required fixed32 offset = 5; +inline bool xtreemfs_internal_read_localRequest::has_offset() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void xtreemfs_internal_read_localRequest::set_has_offset() { + _has_bits_[0] |= 0x00000010u; +} +inline void xtreemfs_internal_read_localRequest::clear_has_offset() { + _has_bits_[0] &= ~0x00000010u; +} +inline void xtreemfs_internal_read_localRequest::clear_offset() { + offset_ = 0u; + clear_has_offset(); +} +inline ::google::protobuf::uint32 xtreemfs_internal_read_localRequest::offset() const { + return offset_; +} +inline void xtreemfs_internal_read_localRequest::set_offset(::google::protobuf::uint32 value) { + set_has_offset(); + offset_ = value; +} + +// required fixed32 length = 6; +inline bool xtreemfs_internal_read_localRequest::has_length() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void xtreemfs_internal_read_localRequest::set_has_length() { + _has_bits_[0] |= 0x00000020u; +} +inline void xtreemfs_internal_read_localRequest::clear_has_length() { + _has_bits_[0] &= ~0x00000020u; +} +inline void xtreemfs_internal_read_localRequest::clear_length() { + length_ = 0u; + clear_has_length(); +} +inline ::google::protobuf::uint32 xtreemfs_internal_read_localRequest::length() const { + return length_; +} +inline void xtreemfs_internal_read_localRequest::set_length(::google::protobuf::uint32 value) { + set_has_length(); + length_ = value; +} + +// required bool attach_object_list = 7; +inline bool xtreemfs_internal_read_localRequest::has_attach_object_list() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void xtreemfs_internal_read_localRequest::set_has_attach_object_list() { + _has_bits_[0] |= 0x00000040u; +} +inline void xtreemfs_internal_read_localRequest::clear_has_attach_object_list() { + _has_bits_[0] &= ~0x00000040u; +} +inline void xtreemfs_internal_read_localRequest::clear_attach_object_list() { + attach_object_list_ = false; + clear_has_attach_object_list(); +} +inline bool xtreemfs_internal_read_localRequest::attach_object_list() const { + return attach_object_list_; +} +inline void xtreemfs_internal_read_localRequest::set_attach_object_list(bool value) { + set_has_attach_object_list(); + attach_object_list_ = value; +} + +// repeated .xtreemfs.pbrpc.ObjectList required_objects = 8; +inline int xtreemfs_internal_read_localRequest::required_objects_size() const { + return required_objects_.size(); +} +inline void xtreemfs_internal_read_localRequest::clear_required_objects() { + required_objects_.Clear(); +} +inline const ::xtreemfs::pbrpc::ObjectList& xtreemfs_internal_read_localRequest::required_objects(int index) const { + return required_objects_.Get(index); +} +inline ::xtreemfs::pbrpc::ObjectList* xtreemfs_internal_read_localRequest::mutable_required_objects(int index) { + return required_objects_.Mutable(index); +} +inline ::xtreemfs::pbrpc::ObjectList* xtreemfs_internal_read_localRequest::add_required_objects() { + return required_objects_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList >& +xtreemfs_internal_read_localRequest::required_objects() const { + return required_objects_; +} +inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::ObjectList >* +xtreemfs_internal_read_localRequest::mutable_required_objects() { + return &required_objects_; +} + +// ------------------------------------------------------------------- + +// xtreemfs_internal_get_object_setRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_internal_get_object_setRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_internal_get_object_setRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_internal_get_object_setRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_internal_get_object_setRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_internal_get_object_setRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_internal_get_object_setRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_internal_get_object_setRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_internal_get_object_setRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_internal_get_object_setRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_internal_get_object_setRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_internal_get_object_setRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_internal_get_object_setRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_internal_get_object_setRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_internal_get_object_setRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_internal_get_object_setRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_internal_get_object_setRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_internal_get_object_setRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_internal_get_object_setRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_internal_get_object_setRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_internal_get_fileid_listResponse + +// repeated string file_ids = 1; +inline int xtreemfs_internal_get_fileid_listResponse::file_ids_size() const { + return file_ids_.size(); +} +inline void xtreemfs_internal_get_fileid_listResponse::clear_file_ids() { + file_ids_.Clear(); +} +inline const ::std::string& xtreemfs_internal_get_fileid_listResponse::file_ids(int index) const { + return file_ids_.Get(index); +} +inline ::std::string* xtreemfs_internal_get_fileid_listResponse::mutable_file_ids(int index) { + return file_ids_.Mutable(index); +} +inline void xtreemfs_internal_get_fileid_listResponse::set_file_ids(int index, const ::std::string& value) { + file_ids_.Mutable(index)->assign(value); +} +inline void xtreemfs_internal_get_fileid_listResponse::set_file_ids(int index, const char* value) { + file_ids_.Mutable(index)->assign(value); +} +inline void xtreemfs_internal_get_fileid_listResponse::set_file_ids(int index, const char* value, size_t size) { + file_ids_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_internal_get_fileid_listResponse::add_file_ids() { + return file_ids_.Add(); +} +inline void xtreemfs_internal_get_fileid_listResponse::add_file_ids(const ::std::string& value) { + file_ids_.Add()->assign(value); +} +inline void xtreemfs_internal_get_fileid_listResponse::add_file_ids(const char* value) { + file_ids_.Add()->assign(value); +} +inline void xtreemfs_internal_get_fileid_listResponse::add_file_ids(const char* value, size_t size) { + file_ids_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +xtreemfs_internal_get_fileid_listResponse::file_ids() const { + return file_ids_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +xtreemfs_internal_get_fileid_listResponse::mutable_file_ids() { + return &file_ids_; +} + +// ------------------------------------------------------------------- + +// lockRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool lockRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void lockRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void lockRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void lockRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& lockRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* lockRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* lockRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void lockRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required .xtreemfs.pbrpc.Lock lock_request = 2; +inline bool lockRequest::has_lock_request() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void lockRequest::set_has_lock_request() { + _has_bits_[0] |= 0x00000002u; +} +inline void lockRequest::clear_has_lock_request() { + _has_bits_[0] &= ~0x00000002u; +} +inline void lockRequest::clear_lock_request() { + if (lock_request_ != NULL) lock_request_->::xtreemfs::pbrpc::Lock::Clear(); + clear_has_lock_request(); +} +inline const ::xtreemfs::pbrpc::Lock& lockRequest::lock_request() const { + return lock_request_ != NULL ? *lock_request_ : *default_instance_->lock_request_; +} +inline ::xtreemfs::pbrpc::Lock* lockRequest::mutable_lock_request() { + set_has_lock_request(); + if (lock_request_ == NULL) lock_request_ = new ::xtreemfs::pbrpc::Lock; + return lock_request_; +} +inline ::xtreemfs::pbrpc::Lock* lockRequest::release_lock_request() { + clear_has_lock_request(); + ::xtreemfs::pbrpc::Lock* temp = lock_request_; + lock_request_ = NULL; + return temp; +} +inline void lockRequest::set_allocated_lock_request(::xtreemfs::pbrpc::Lock* lock_request) { + delete lock_request_; + lock_request_ = lock_request; + if (lock_request) { + set_has_lock_request(); + } else { + clear_has_lock_request(); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_pingMesssage + +// required .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 1; +inline bool xtreemfs_pingMesssage::has_coordinates() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_pingMesssage::set_has_coordinates() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_pingMesssage::clear_has_coordinates() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_pingMesssage::clear_coordinates() { + if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear(); + clear_has_coordinates(); +} +inline const ::xtreemfs::pbrpc::VivaldiCoordinates& xtreemfs_pingMesssage::coordinates() const { + return coordinates_ != NULL ? *coordinates_ : *default_instance_->coordinates_; +} +inline ::xtreemfs::pbrpc::VivaldiCoordinates* xtreemfs_pingMesssage::mutable_coordinates() { + set_has_coordinates(); + if (coordinates_ == NULL) coordinates_ = new ::xtreemfs::pbrpc::VivaldiCoordinates; + return coordinates_; +} +inline ::xtreemfs::pbrpc::VivaldiCoordinates* xtreemfs_pingMesssage::release_coordinates() { + clear_has_coordinates(); + ::xtreemfs::pbrpc::VivaldiCoordinates* temp = coordinates_; + coordinates_ = NULL; + return temp; +} +inline void xtreemfs_pingMesssage::set_allocated_coordinates(::xtreemfs::pbrpc::VivaldiCoordinates* coordinates) { + delete coordinates_; + coordinates_ = coordinates; + if (coordinates) { + set_has_coordinates(); + } else { + clear_has_coordinates(); + } +} + +// required bool request_response = 2; +inline bool xtreemfs_pingMesssage::has_request_response() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_pingMesssage::set_has_request_response() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_pingMesssage::clear_has_request_response() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_pingMesssage::clear_request_response() { + request_response_ = false; + clear_has_request_response(); +} +inline bool xtreemfs_pingMesssage::request_response() const { + return request_response_; +} +inline void xtreemfs_pingMesssage::set_request_response(bool value) { + set_has_request_response(); + request_response_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_rwr_auth_stateRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_rwr_auth_stateRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rwr_auth_stateRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rwr_auth_stateRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rwr_auth_stateRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_rwr_auth_stateRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_auth_stateRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_auth_stateRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_rwr_auth_stateRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_rwr_auth_stateRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_rwr_auth_stateRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_rwr_auth_stateRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_rwr_auth_stateRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_rwr_auth_stateRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_rwr_auth_stateRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_auth_stateRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_auth_stateRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rwr_auth_stateRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_rwr_auth_stateRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rwr_auth_stateRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required .xtreemfs.pbrpc.AuthoritativeReplicaState state = 3; +inline bool xtreemfs_rwr_auth_stateRequest::has_state() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_rwr_auth_stateRequest::set_has_state() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_rwr_auth_stateRequest::clear_has_state() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_rwr_auth_stateRequest::clear_state() { + if (state_ != NULL) state_->::xtreemfs::pbrpc::AuthoritativeReplicaState::Clear(); + clear_has_state(); +} +inline const ::xtreemfs::pbrpc::AuthoritativeReplicaState& xtreemfs_rwr_auth_stateRequest::state() const { + return state_ != NULL ? *state_ : *default_instance_->state_; +} +inline ::xtreemfs::pbrpc::AuthoritativeReplicaState* xtreemfs_rwr_auth_stateRequest::mutable_state() { + set_has_state(); + if (state_ == NULL) state_ = new ::xtreemfs::pbrpc::AuthoritativeReplicaState; + return state_; +} +inline ::xtreemfs::pbrpc::AuthoritativeReplicaState* xtreemfs_rwr_auth_stateRequest::release_state() { + clear_has_state(); + ::xtreemfs::pbrpc::AuthoritativeReplicaState* temp = state_; + state_ = NULL; + return temp; +} +inline void xtreemfs_rwr_auth_stateRequest::set_allocated_state(::xtreemfs::pbrpc::AuthoritativeReplicaState* state) { + delete state_; + state_ = state; + if (state) { + set_has_state(); + } else { + clear_has_state(); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_rwr_reset_completeRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_rwr_reset_completeRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_rwr_reset_completeRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_rwr_reset_completeRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_rwr_reset_completeRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_rwr_reset_completeRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_reset_completeRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_rwr_reset_completeRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_rwr_reset_completeRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_rwr_reset_completeRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_rwr_reset_completeRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_rwr_reset_completeRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_rwr_reset_completeRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_rwr_reset_completeRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_rwr_reset_completeRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_reset_completeRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_rwr_reset_completeRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_rwr_reset_completeRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_rwr_reset_completeRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_rwr_reset_completeRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required fixed32 primary_epoch = 3; +inline bool xtreemfs_rwr_reset_completeRequest::has_primary_epoch() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void xtreemfs_rwr_reset_completeRequest::set_has_primary_epoch() { + _has_bits_[0] |= 0x00000004u; +} +inline void xtreemfs_rwr_reset_completeRequest::clear_has_primary_epoch() { + _has_bits_[0] &= ~0x00000004u; +} +inline void xtreemfs_rwr_reset_completeRequest::clear_primary_epoch() { + primary_epoch_ = 0u; + clear_has_primary_epoch(); +} +inline ::google::protobuf::uint32 xtreemfs_rwr_reset_completeRequest::primary_epoch() const { + return primary_epoch_; +} +inline void xtreemfs_rwr_reset_completeRequest::set_primary_epoch(::google::protobuf::uint32 value) { + set_has_primary_epoch(); + primary_epoch_ = value; +} + +// ------------------------------------------------------------------- + +// xtreemfs_xloc_set_invalidateRequest + +// required .xtreemfs.pbrpc.FileCredentials file_credentials = 1; +inline bool xtreemfs_xloc_set_invalidateRequest::has_file_credentials() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_xloc_set_invalidateRequest::set_has_file_credentials() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_xloc_set_invalidateRequest::clear_has_file_credentials() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_xloc_set_invalidateRequest::clear_file_credentials() { + if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear(); + clear_has_file_credentials(); +} +inline const ::xtreemfs::pbrpc::FileCredentials& xtreemfs_xloc_set_invalidateRequest::file_credentials() const { + return file_credentials_ != NULL ? *file_credentials_ : *default_instance_->file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_xloc_set_invalidateRequest::mutable_file_credentials() { + set_has_file_credentials(); + if (file_credentials_ == NULL) file_credentials_ = new ::xtreemfs::pbrpc::FileCredentials; + return file_credentials_; +} +inline ::xtreemfs::pbrpc::FileCredentials* xtreemfs_xloc_set_invalidateRequest::release_file_credentials() { + clear_has_file_credentials(); + ::xtreemfs::pbrpc::FileCredentials* temp = file_credentials_; + file_credentials_ = NULL; + return temp; +} +inline void xtreemfs_xloc_set_invalidateRequest::set_allocated_file_credentials(::xtreemfs::pbrpc::FileCredentials* file_credentials) { + delete file_credentials_; + file_credentials_ = file_credentials; + if (file_credentials) { + set_has_file_credentials(); + } else { + clear_has_file_credentials(); + } +} + +// required string file_id = 2; +inline bool xtreemfs_xloc_set_invalidateRequest::has_file_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_xloc_set_invalidateRequest::set_has_file_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_xloc_set_invalidateRequest::clear_has_file_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_xloc_set_invalidateRequest::clear_file_id() { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + file_id_->clear(); + } + clear_has_file_id(); +} +inline const ::std::string& xtreemfs_xloc_set_invalidateRequest::file_id() const { + return *file_id_; +} +inline void xtreemfs_xloc_set_invalidateRequest::set_file_id(const ::std::string& value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_xloc_set_invalidateRequest::set_file_id(const char* value) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(value); +} +inline void xtreemfs_xloc_set_invalidateRequest::set_file_id(const char* value, size_t size) { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + file_id_->assign(reinterpret_cast(value), size); +} +inline ::std::string* xtreemfs_xloc_set_invalidateRequest::mutable_file_id() { + set_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + file_id_ = new ::std::string; + } + return file_id_; +} +inline ::std::string* xtreemfs_xloc_set_invalidateRequest::release_file_id() { + clear_has_file_id(); + if (file_id_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = file_id_; + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void xtreemfs_xloc_set_invalidateRequest::set_allocated_file_id(::std::string* file_id) { + if (file_id_ != &::google::protobuf::internal::kEmptyString) { + delete file_id_; + } + if (file_id) { + set_has_file_id(); + file_id_ = file_id; + } else { + clear_has_file_id(); + file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// xtreemfs_xloc_set_invalidateResponse + +// required .xtreemfs.pbrpc.LeaseState lease_state = 1; +inline bool xtreemfs_xloc_set_invalidateResponse::has_lease_state() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void xtreemfs_xloc_set_invalidateResponse::set_has_lease_state() { + _has_bits_[0] |= 0x00000001u; +} +inline void xtreemfs_xloc_set_invalidateResponse::clear_has_lease_state() { + _has_bits_[0] &= ~0x00000001u; +} +inline void xtreemfs_xloc_set_invalidateResponse::clear_lease_state() { + lease_state_ = 0; + clear_has_lease_state(); +} +inline ::xtreemfs::pbrpc::LeaseState xtreemfs_xloc_set_invalidateResponse::lease_state() const { + return static_cast< ::xtreemfs::pbrpc::LeaseState >(lease_state_); +} +inline void xtreemfs_xloc_set_invalidateResponse::set_lease_state(::xtreemfs::pbrpc::LeaseState value) { + assert(::xtreemfs::pbrpc::LeaseState_IsValid(value)); + set_has_lease_state(); + lease_state_ = value; +} + +// optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2; +inline bool xtreemfs_xloc_set_invalidateResponse::has_replica_status() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void xtreemfs_xloc_set_invalidateResponse::set_has_replica_status() { + _has_bits_[0] |= 0x00000002u; +} +inline void xtreemfs_xloc_set_invalidateResponse::clear_has_replica_status() { + _has_bits_[0] &= ~0x00000002u; +} +inline void xtreemfs_xloc_set_invalidateResponse::clear_replica_status() { + if (replica_status_ != NULL) replica_status_->::xtreemfs::pbrpc::ReplicaStatus::Clear(); + clear_has_replica_status(); +} +inline const ::xtreemfs::pbrpc::ReplicaStatus& xtreemfs_xloc_set_invalidateResponse::replica_status() const { + return replica_status_ != NULL ? *replica_status_ : *default_instance_->replica_status_; +} +inline ::xtreemfs::pbrpc::ReplicaStatus* xtreemfs_xloc_set_invalidateResponse::mutable_replica_status() { + set_has_replica_status(); + if (replica_status_ == NULL) replica_status_ = new ::xtreemfs::pbrpc::ReplicaStatus; + return replica_status_; +} +inline ::xtreemfs::pbrpc::ReplicaStatus* xtreemfs_xloc_set_invalidateResponse::release_replica_status() { + clear_has_replica_status(); + ::xtreemfs::pbrpc::ReplicaStatus* temp = replica_status_; + replica_status_ = NULL; + return temp; +} +inline void xtreemfs_xloc_set_invalidateResponse::set_allocated_replica_status(::xtreemfs::pbrpc::ReplicaStatus* replica_status) { + delete replica_status_; + replica_status_ = replica_status; + if (replica_status) { + set_has_replica_status(); + } else { + clear_has_replica_status(); + } +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pbrpc +} // namespace xtreemfs + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::OSDHealthResult>() { + return ::xtreemfs::pbrpc::OSDHealthResult_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_xtreemfs_2fOSD_2eproto__INCLUDED diff --git a/cpp/generated/xtreemfs/OSDServiceClient.h b/cpp/generated/xtreemfs/OSDServiceClient.h new file mode 100644 index 0000000..4729173 --- /dev/null +++ b/cpp/generated/xtreemfs/OSDServiceClient.h @@ -0,0 +1,838 @@ +//automatically generated from OSD.proto at Thu Dec 11 16:09:41 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef OSDSERVICECLIENT_H +#define OSDSERVICECLIENT_H + +#include +#include "pbrpc/RPC.pb.h" +#include "rpc/client.h" +#include "rpc/sync_callback.h" +#include "rpc/callback_interface.h" +#include "xtreemfs/OSD.pb.h" +#include "xtreemfs/MRC.pb.h" +#include "include/Common.pb.h" +#include "xtreemfs/GlobalTypes.pb.h" +#include "xtreemfs/DIR.pb.h" + + +namespace xtreemfs { +namespace pbrpc { + using ::xtreemfs::rpc::Client; + using ::xtreemfs::rpc::CallbackInterface; + using ::xtreemfs::rpc::SyncCallback; + + class OSDServiceClient { + + public: + OSDServiceClient(Client* client) : client_(client) { + } + + virtual ~OSDServiceClient() { + } + + void read(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::readRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 10, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectData(), + context, callback); + } + + SyncCallback* read_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::readRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 10, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectData(), + NULL, sync_cb); + return sync_cb; + } + + void truncate(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::truncateRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 11, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::OSDWriteResponse(), + context, callback); + } + + SyncCallback* truncate_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::truncateRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 11, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::OSDWriteResponse(), + NULL, sync_cb); + return sync_cb; + } + + void unlink(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::unlink_osd_Request* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 12, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* unlink_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::unlink_osd_Request* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 12, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void write(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::writeRequest* request,const char* data, uint32_t data_length, + CallbackInterface *callback, void *context = NULL) { + client_->sendRequest(address, 30001, 13, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::OSDWriteResponse(), + context, callback); + } + + SyncCallback* write_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::writeRequest* request, const char* data, uint32_t data_length) { + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 13, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::OSDWriteResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_broadcast_gmax(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_broadcast_gmaxRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 20, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_broadcast_gmax_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_broadcast_gmaxRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 20, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_check_object(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_check_objectRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 21, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectData(), + context, callback); + } + + SyncCallback* xtreemfs_check_object_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_check_objectRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 21, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectData(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_cleanup_get_results(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 30001, 30, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_cleanup_get_resultsResponse(), + context, callback); + } + + SyncCallback* xtreemfs_cleanup_get_results_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 30, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_cleanup_get_resultsResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_cleanup_is_running(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 30001, 31, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_cleanup_is_runningResponse(), + context, callback); + } + + SyncCallback* xtreemfs_cleanup_is_running_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 31, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_cleanup_is_runningResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_cleanup_start(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_cleanup_startRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 32, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_cleanup_start_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_cleanup_startRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 32, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_cleanup_status(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 30001, 33, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_cleanup_statusResponse(), + context, callback); + } + + SyncCallback* xtreemfs_cleanup_status_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 33, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_cleanup_statusResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_cleanup_stop(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 30001, 34, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_cleanup_stop_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 34, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_cleanup_versions_start(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 30001, 35, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_cleanup_versions_start_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 35, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_repair_object(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_repair_objectRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 36, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_repair_object_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_repair_objectRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 36, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_fetch(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_fetchRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 73, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectData(), + context, callback); + } + + SyncCallback* xtreemfs_rwr_fetch_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_fetchRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 73, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectData(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_flease_msg(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_flease_msgRequest* request,const char* data, uint32_t data_length, + CallbackInterface *callback, void *context = NULL) { + client_->sendRequest(address, 30001, 71, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_rwr_flease_msg_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_flease_msgRequest* request, const char* data, uint32_t data_length) { + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 71, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_notify(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::FileCredentials* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 75, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_rwr_notify_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::FileCredentials* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 75, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_set_primary_epoch(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_set_primary_epochRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 78, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectData(), + context, callback); + } + + SyncCallback* xtreemfs_rwr_set_primary_epoch_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_set_primary_epochRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 78, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectData(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_status(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_statusRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 76, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ReplicaStatus(), + context, callback); + } + + SyncCallback* xtreemfs_rwr_status_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_statusRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 76, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ReplicaStatus(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_truncate(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_truncateRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 74, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_rwr_truncate_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_truncateRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 74, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_update(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_updateRequest* request,const char* data, uint32_t data_length, + CallbackInterface *callback, void *context = NULL) { + client_->sendRequest(address, 30001, 72, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_rwr_update_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_updateRequest* request, const char* data, uint32_t data_length) { + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 72, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_auth_state(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_auth_stateRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 79, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_rwr_auth_state_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_auth_stateRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 79, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_reset_complete(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_reset_completeRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 80, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_rwr_reset_complete_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_reset_completeRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 80, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_internal_get_gmax(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_internal_get_gmaxRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 40, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::InternalGmax(), + context, callback); + } + + SyncCallback* xtreemfs_internal_get_gmax_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_internal_get_gmaxRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 40, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::InternalGmax(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_internal_truncate(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::truncateRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 41, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::OSDWriteResponse(), + context, callback); + } + + SyncCallback* xtreemfs_internal_truncate_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::truncateRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 41, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::OSDWriteResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_internal_get_file_size(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_internal_get_file_sizeRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 42, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_internal_get_file_sizeResponse(), + context, callback); + } + + SyncCallback* xtreemfs_internal_get_file_size_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_internal_get_file_sizeRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 42, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_internal_get_file_sizeResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_internal_read_local(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_internal_read_localRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 43, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::InternalReadLocalResponse(), + context, callback); + } + + SyncCallback* xtreemfs_internal_read_local_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_internal_read_localRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 43, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::InternalReadLocalResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_internal_get_object_set(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_internal_get_object_setRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 44, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectList(), + context, callback); + } + + SyncCallback* xtreemfs_internal_get_object_set_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_internal_get_object_setRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 44, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::ObjectList(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_internal_get_fileid_list(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 30001, 45, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_internal_get_fileid_listResponse(), + context, callback); + } + + SyncCallback* xtreemfs_internal_get_fileid_list_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 45, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_internal_get_fileid_listResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_lock_acquire(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::lockRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 50, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Lock(), + context, callback); + } + + SyncCallback* xtreemfs_lock_acquire_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::lockRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 50, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Lock(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_lock_check(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::lockRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 51, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Lock(), + context, callback); + } + + SyncCallback* xtreemfs_lock_check_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::lockRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 51, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::Lock(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_lock_release(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::lockRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 52, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_lock_release_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::lockRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 52, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_ping(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_pingMesssage* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 60, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_pingMesssage(), + context, callback); + } + + SyncCallback* xtreemfs_ping_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_pingMesssage* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 60, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_pingMesssage(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_shutdown(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + client_->sendRequest(address, 30001, 70, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_shutdown_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds) { + const char* data = NULL; uint32_t data_length = 0; + xtreemfs::pbrpc::emptyRequest* request = NULL; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 70, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_xloc_set_invalidate(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_xloc_set_invalidateRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 81, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_xloc_set_invalidateResponse(), + context, callback); + } + + SyncCallback* xtreemfs_xloc_set_invalidate_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_xloc_set_invalidateRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 81, + creds, auth, request, data, data_length, new xtreemfs::pbrpc::xtreemfs_xloc_set_invalidateResponse(), + NULL, sync_cb); + return sync_cb; + } + + void xtreemfs_rwr_auth_state_invalidated(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds, + const xtreemfs::pbrpc::xtreemfs_rwr_auth_stateRequest* request, + CallbackInterface *callback, void *context = NULL) { + const char* data = NULL; uint32_t data_length = 0; + client_->sendRequest(address, 30001, 82, + creds, auth, request, data, data_length, NULL, + context, callback); + } + + SyncCallback* xtreemfs_rwr_auth_state_invalidated_sync(const std::string &address, + const xtreemfs::pbrpc::Auth& auth, + const xtreemfs::pbrpc::UserCredentials &creds + , const xtreemfs::pbrpc::xtreemfs_rwr_auth_stateRequest* request) { + const char* data = NULL; uint32_t data_length = 0; + SyncCallback* sync_cb = new SyncCallback(); + client_->sendRequest(address, 30001, 82, + creds, auth, request, data, data_length, NULL, + NULL, sync_cb); + return sync_cb; + } + + private: + Client* client_; + }; + } +} +#endif //OSDSERVICECLIENT_H diff --git a/cpp/generated/xtreemfs/OSDServiceConstants.h b/cpp/generated/xtreemfs/OSDServiceConstants.h new file mode 100644 index 0000000..2204d25 --- /dev/null +++ b/cpp/generated/xtreemfs/OSDServiceConstants.h @@ -0,0 +1,51 @@ +//automatically generated from OSD.proto at Thu Dec 11 16:09:41 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef OSDSERVICECONSTANTS_H_ +#define OSDSERVICECONSTANTS_H_ +#include + +namespace xtreemfs { +namespace pbrpc { + +const uint32_t INTERFACE_ID_OSD = 30001; +const uint32_t PROC_ID_READ = 10; +const uint32_t PROC_ID_TRUNCATE = 11; +const uint32_t PROC_ID_UNLINK = 12; +const uint32_t PROC_ID_WRITE = 13; +const uint32_t PROC_ID_XTREEMFS_BROADCAST_GMAX = 20; +const uint32_t PROC_ID_XTREEMFS_CHECK_OBJECT = 21; +const uint32_t PROC_ID_XTREEMFS_CLEANUP_GET_RESULTS = 30; +const uint32_t PROC_ID_XTREEMFS_CLEANUP_IS_RUNNING = 31; +const uint32_t PROC_ID_XTREEMFS_CLEANUP_START = 32; +const uint32_t PROC_ID_XTREEMFS_CLEANUP_STATUS = 33; +const uint32_t PROC_ID_XTREEMFS_CLEANUP_STOP = 34; +const uint32_t PROC_ID_XTREEMFS_CLEANUP_VERSIONS_START = 35; +const uint32_t PROC_ID_XTREEMFS_REPAIR_OBJECT = 36; +const uint32_t PROC_ID_XTREEMFS_RWR_FETCH = 73; +const uint32_t PROC_ID_XTREEMFS_RWR_FLEASE_MSG = 71; +const uint32_t PROC_ID_XTREEMFS_RWR_NOTIFY = 75; +const uint32_t PROC_ID_XTREEMFS_RWR_SET_PRIMARY_EPOCH = 78; +const uint32_t PROC_ID_XTREEMFS_RWR_STATUS = 76; +const uint32_t PROC_ID_XTREEMFS_RWR_TRUNCATE = 74; +const uint32_t PROC_ID_XTREEMFS_RWR_UPDATE = 72; +const uint32_t PROC_ID_XTREEMFS_RWR_AUTH_STATE = 79; +const uint32_t PROC_ID_XTREEMFS_RWR_RESET_COMPLETE = 80; +const uint32_t PROC_ID_XTREEMFS_INTERNAL_GET_GMAX = 40; +const uint32_t PROC_ID_XTREEMFS_INTERNAL_TRUNCATE = 41; +const uint32_t PROC_ID_XTREEMFS_INTERNAL_GET_FILE_SIZE = 42; +const uint32_t PROC_ID_XTREEMFS_INTERNAL_READ_LOCAL = 43; +const uint32_t PROC_ID_XTREEMFS_INTERNAL_GET_OBJECT_SET = 44; +const uint32_t PROC_ID_XTREEMFS_INTERNAL_GET_FILEID_LIST = 45; +const uint32_t PROC_ID_XTREEMFS_LOCK_ACQUIRE = 50; +const uint32_t PROC_ID_XTREEMFS_LOCK_CHECK = 51; +const uint32_t PROC_ID_XTREEMFS_LOCK_RELEASE = 52; +const uint32_t PROC_ID_XTREEMFS_PING = 60; +const uint32_t PROC_ID_XTREEMFS_SHUTDOWN = 70; +const uint32_t PROC_ID_XTREEMFS_XLOC_SET_INVALIDATE = 81; +const uint32_t PROC_ID_XTREEMFS_RWR_AUTH_STATE_INVALIDATED = 82; + +} // namespace pbrpc +} // namespace xtreemfs + +#endif // OSDSERVICECLIENT_H_ diff --git a/cpp/generated/xtreemfs/get_request_message.cc b/cpp/generated/xtreemfs/get_request_message.cc new file mode 100644 index 0000000..f8ec99a --- /dev/null +++ b/cpp/generated/xtreemfs/get_request_message.cc @@ -0,0 +1,420 @@ +//automatically generated at Thu Dec 11 16:09:40 CET 2014 +//(c) 2014. See LICENSE file for details. + +#include "xtreemfs/get_request_message.h" + +#include "xtreemfs/OSD.pb.h" +#include "xtreemfs/MRC.pb.h" +#include "include/Common.pb.h" +#include "xtreemfs/GlobalTypes.pb.h" +#include "xtreemfs/DIR.pb.h" + +namespace xtreemfs { +namespace pbrpc { + +google::protobuf::Message* GetMessageForProcID(uint32_t interface_id, + uint32_t proc_id) { + switch (interface_id) { +// Generated from DIR.proto + case 10001: { + switch (proc_id) { + case 1: { + return new xtreemfs::pbrpc::addressMappingGetRequest(); + break; + } + case 2: { + return new xtreemfs::pbrpc::addressMappingGetRequest(); + break; + } + case 3: { + return new xtreemfs::pbrpc::AddressMappingSet(); + break; + } + case 4: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 5: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 6: { + return new xtreemfs::pbrpc::serviceDeregisterRequest(); + break; + } + case 7: { + return new xtreemfs::pbrpc::serviceGetByNameRequest(); + break; + } + case 8: { + return new xtreemfs::pbrpc::serviceGetByTypeRequest(); + break; + } + case 9: { + return new xtreemfs::pbrpc::serviceGetByUUIDRequest(); + break; + } + case 10: { + return new xtreemfs::pbrpc::serviceGetByUUIDRequest(); + break; + } + case 11: { + return new xtreemfs::pbrpc::serviceRegisterRequest(); + break; + } + case 20: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 21: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 22: { + return new xtreemfs::pbrpc::configurationGetRequest(); + break; + } + case 23: { + return new xtreemfs::pbrpc::Configuration(); + break; + } + case 24: { + return new xtreemfs::pbrpc::VivaldiCoordinates(); + break; + } + default: { + return NULL; + } + } + break; + } +// Generated from MRC.proto + case 20001: { + switch (proc_id) { + case 2: { + return new xtreemfs::pbrpc::fsetattrRequest(); + break; + } + case 3: { + return new xtreemfs::pbrpc::XCap(); + break; + } + case 4: { + return new xtreemfs::pbrpc::getattrRequest(); + break; + } + case 5: { + return new xtreemfs::pbrpc::getxattrRequest(); + break; + } + case 6: { + return new xtreemfs::pbrpc::linkRequest(); + break; + } + case 7: { + return new xtreemfs::pbrpc::listxattrRequest(); + break; + } + case 8: { + return new xtreemfs::pbrpc::mkdirRequest(); + break; + } + case 9: { + return new xtreemfs::pbrpc::openRequest(); + break; + } + case 10: { + return new xtreemfs::pbrpc::readdirRequest(); + break; + } + case 11: { + return new xtreemfs::pbrpc::readlinkRequest(); + break; + } + case 12: { + return new xtreemfs::pbrpc::removexattrRequest(); + break; + } + case 13: { + return new xtreemfs::pbrpc::renameRequest(); + break; + } + case 14: { + return new xtreemfs::pbrpc::rmdirRequest(); + break; + } + case 15: { + return new xtreemfs::pbrpc::setattrRequest(); + break; + } + case 16: { + return new xtreemfs::pbrpc::setxattrRequest(); + break; + } + case 17: { + return new xtreemfs::pbrpc::statvfsRequest(); + break; + } + case 18: { + return new xtreemfs::pbrpc::symlinkRequest(); + break; + } + case 19: { + return new xtreemfs::pbrpc::unlinkRequest(); + break; + } + case 20: { + return new xtreemfs::pbrpc::accessRequest(); + break; + } + case 30: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 31: { + return new xtreemfs::pbrpc::xtreemfs_check_file_existsRequest(); + break; + } + case 32: { + return new xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest(); + break; + } + case 33: { + return new xtreemfs::pbrpc::xtreemfs_get_suitable_osdsRequest(); + break; + } + case 34: { + return new xtreemfs::pbrpc::stringMessage(); + break; + } + case 35: { + return new xtreemfs::pbrpc::xtreemfs_listdirRequest(); + break; + } + case 36: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 47: { + return new xtreemfs::pbrpc::Volume(); + break; + } + case 37: { + return new xtreemfs::pbrpc::XCap(); + break; + } + case 38: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 39: { + return new xtreemfs::pbrpc::xtreemfs_replica_addRequest(); + break; + } + case 40: { + return new xtreemfs::pbrpc::xtreemfs_replica_listRequest(); + break; + } + case 41: { + return new xtreemfs::pbrpc::xtreemfs_replica_removeRequest(); + break; + } + case 42: { + return new xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest(); + break; + } + case 43: { + return new xtreemfs::pbrpc::xtreemfs_restore_fileRequest(); + break; + } + case 44: { + return new xtreemfs::pbrpc::xtreemfs_rmvolRequest(); + break; + } + case 45: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 46: { + return new xtreemfs::pbrpc::xtreemfs_update_file_sizeRequest(); + break; + } + case 48: { + return new xtreemfs::pbrpc::xtreemfs_set_replica_update_policyRequest(); + break; + } + case 49: { + return new xtreemfs::pbrpc::xtreemfs_set_read_only_xattrRequest(); + break; + } + case 50: { + return new xtreemfs::pbrpc::xtreemfs_get_file_credentialsRequest(); + break; + } + case 51: { + return new xtreemfs::pbrpc::xtreemfs_get_xlocsetRequest(); + break; + } + default: { + return NULL; + } + } + break; + } +// Generated from OSD.proto + case 30001: { + switch (proc_id) { + case 10: { + return new xtreemfs::pbrpc::readRequest(); + break; + } + case 11: { + return new xtreemfs::pbrpc::truncateRequest(); + break; + } + case 12: { + return new xtreemfs::pbrpc::unlink_osd_Request(); + break; + } + case 13: { + return new xtreemfs::pbrpc::writeRequest(); + break; + } + case 20: { + return new xtreemfs::pbrpc::xtreemfs_broadcast_gmaxRequest(); + break; + } + case 21: { + return new xtreemfs::pbrpc::xtreemfs_check_objectRequest(); + break; + } + case 30: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 31: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 32: { + return new xtreemfs::pbrpc::xtreemfs_cleanup_startRequest(); + break; + } + case 33: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 34: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 35: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 36: { + return new xtreemfs::pbrpc::xtreemfs_repair_objectRequest(); + break; + } + case 73: { + return new xtreemfs::pbrpc::xtreemfs_rwr_fetchRequest(); + break; + } + case 71: { + return new xtreemfs::pbrpc::xtreemfs_rwr_flease_msgRequest(); + break; + } + case 75: { + return new xtreemfs::pbrpc::FileCredentials(); + break; + } + case 78: { + return new xtreemfs::pbrpc::xtreemfs_rwr_set_primary_epochRequest(); + break; + } + case 76: { + return new xtreemfs::pbrpc::xtreemfs_rwr_statusRequest(); + break; + } + case 74: { + return new xtreemfs::pbrpc::xtreemfs_rwr_truncateRequest(); + break; + } + case 72: { + return new xtreemfs::pbrpc::xtreemfs_rwr_updateRequest(); + break; + } + case 79: { + return new xtreemfs::pbrpc::xtreemfs_rwr_auth_stateRequest(); + break; + } + case 80: { + return new xtreemfs::pbrpc::xtreemfs_rwr_reset_completeRequest(); + break; + } + case 40: { + return new xtreemfs::pbrpc::xtreemfs_internal_get_gmaxRequest(); + break; + } + case 41: { + return new xtreemfs::pbrpc::truncateRequest(); + break; + } + case 42: { + return new xtreemfs::pbrpc::xtreemfs_internal_get_file_sizeRequest(); + break; + } + case 43: { + return new xtreemfs::pbrpc::xtreemfs_internal_read_localRequest(); + break; + } + case 44: { + return new xtreemfs::pbrpc::xtreemfs_internal_get_object_setRequest(); + break; + } + case 45: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 50: { + return new xtreemfs::pbrpc::lockRequest(); + break; + } + case 51: { + return new xtreemfs::pbrpc::lockRequest(); + break; + } + case 52: { + return new xtreemfs::pbrpc::lockRequest(); + break; + } + case 60: { + return new xtreemfs::pbrpc::xtreemfs_pingMesssage(); + break; + } + case 70: { + return new xtreemfs::pbrpc::emptyRequest(); + break; + } + case 81: { + return new xtreemfs::pbrpc::xtreemfs_xloc_set_invalidateRequest(); + break; + } + case 82: { + return new xtreemfs::pbrpc::xtreemfs_rwr_auth_stateRequest(); + break; + } + default: { + return NULL; + } + } + break; + } + default: { + return NULL; + } + } +} + +} // namespace pbrpc +} // namespace xtreemfs diff --git a/cpp/generated/xtreemfs/get_request_message.h b/cpp/generated/xtreemfs/get_request_message.h new file mode 100644 index 0000000..2ad1b02 --- /dev/null +++ b/cpp/generated/xtreemfs/get_request_message.h @@ -0,0 +1,24 @@ +//automatically generated at Thu Dec 11 16:09:40 CET 2014 +//(c) 2014. See LICENSE file for details. + +#ifndef CPP_GENERATED_XTREEMFS_GET_REQUEST_MESSAGE_H_ +#define CPP_GENERATED_XTREEMFS_GET_REQUEST_MESSAGE_H_ + +#include + +namespace google { +namespace protobuf { +class Message; +} // namespace protobuf +} // namespace google + +namespace xtreemfs { +namespace pbrpc { + +google::protobuf::Message* GetMessageForProcID(uint32_t interface_id, + uint32_t proc_id); + +} // namespace pbrpc +} // namespace xtreemfs + +#endif // CPP_GENERATED_XTREEMFS_GET_REQUEST_MESSAGE_H_ diff --git a/cpp/include/cbfs/cbfs_adapter.h b/cpp/include/cbfs/cbfs_adapter.h new file mode 100644 index 0000000..dd2a5a3 --- /dev/null +++ b/cpp/include/cbfs/cbfs_adapter.h @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2012 by Michael Berlin, Zuse Institute Berlin + * + * Licensed under the BSD License, see LICENSE file for details. + * + */ + +#ifndef CPP_INCLUDE_CBFS_CBFS_ADAPTER_H_ +#define CPP_INCLUDE_CBFS_CBFS_ADAPTER_H_ + +#define WIN32_LEAN_AND_MEAN +#include // required for CbFS.h + +#include +#include +#include +#include +#include + +#include "xtfsutil/xtfsutil_server.h" +#include "xtreemfs/GlobalTypes.pb.h" + +namespace xtreemfs { + +namespace pbrpc { +class Stat; +} // namespace pbrpc + +class CbFSOptions; +class Client; +class SystemUserMapping; + +class CbFSAdapter { + public: + /** Replace "\" path separator by "/" and convert UTF-16 to UTF-8. */ + static std::string WindowsPathToUTF8Unix(const wchar_t* from); + + static void DebugPrintCreateFile( + LPCWSTR OperationType, + LPCTSTR FileName, + ACCESS_MASK DesiredAccess, + DWORD FileAttributes, + DWORD ShareMode, + PVOID FileHandleContext); + + /** Creates a new instance of CbFSAdapter, but does not create any + * libxtreemfs Client yet. + * + * Use Start() to actually create the client and mount the volume given in + * options. May modify options. + */ + explicit CbFSAdapter(CbFSOptions* options); + + ~CbFSAdapter(); + + /** Create client, open volume and start needed threads. */ + void Start(); + + /** Shutdown threads, close Volume and Client and blocks until all threads + * are stopped. */ + void Stop(); + + /** Same as Stop(), but does not call cbfs_.UnmountMedia(). */ + void StopWithoutUnmount(); + + void GetVolumeSize(CallbackFileSystem* Sender, + __int64* TotalNumberOfSectors, + __int64* NumberOfFreeSectors); + + void GetVolumeLabel(CallbackFileSystem* Sender, LPTSTR VolumeLabel); + + void GetVolumeId(CallbackFileSystem* Sender, PDWORD VolumeID); + + void CreateFile(CallbackFileSystem* Sender, + LPCTSTR FileName, + ACCESS_MASK DesiredAccess, + DWORD FileAttributes, + DWORD ShareMode, + PVOID* FileHandleContext); + + void OpenFile(CallbackFileSystem* Sender, + LPCTSTR FileName, + ACCESS_MASK DesiredAccess, + DWORD ShareMode, + PVOID* FileHandleContext); + + void CloseFile(CallbackFileSystem* Sender, + CbFsFileInfo* FileInfo, + PVOID FileHandleContext); + + void GetFileInfo(CallbackFileSystem* Sender, + LPCTSTR FileName, + LPBOOL FileExists, + PFILETIME CreationTime, + PFILETIME LastAccessTime, + PFILETIME LastWriteTime, + __int64* EndOfFile, + __int64* AllocationSize, + __int64* FileId, + PDWORD FileAttributes, + LPTSTR LongFileName OPTIONAL, + PWORD LongFileNameLength OPTIONAL); + + void EnumerateDirectory(CallbackFileSystem* Sender, + CbFsFileInfo* DirectoryInfo, + PVOID* EnumerationContext, + LPCTSTR Mask, + INT Index, + BOOL Restart, + LPBOOL FileFound, + LPTSTR FileName, + PDWORD FileNameLength, + LPTSTR ShortFileName OPTIONAL, + PUCHAR ShortFileNameLength OPTIONAL, + PFILETIME CreationTime, + PFILETIME LastAccessTime, + PFILETIME LastWriteTime, + __int64* EndOfFile, + __int64* AllocationSize, + __int64* FileId, + PDWORD FileAttributes); + + void CloseEnumeration(CallbackFileSystem* Sender, + CbFsFileInfo* DirectoryInfo, + PVOID EnumerationContext); + + void SetAllocationSize(CallbackFileSystem* Sender, + CbFsFileInfo* FileInfo, + PVOID FileHandleContext, + __int64 AllocationSize); + + void SetEndOfFile(CallbackFileSystem* Sender, + CbFsFileInfo* FileInfo, + PVOID FileHandleContext, + __int64 EndOfFile); + + void SetFileAttributes(CallbackFileSystem* Sender, + CbFsFileInfo* FileInfo, + PVOID FileHandleContext, + PFILETIME CreationTime, + PFILETIME LastAccessTime, + PFILETIME LastWriteTime, + DWORD FileAttributes); + + void CanFileBeDeleted(CallbackFileSystem* Sender, + CbFsFileInfo* FileInfo, + BOOL* CanBeDeleted); + + void DeleteFile(CallbackFileSystem* Sender, CbFsFileInfo* FileInfo); + + void RenameOrMoveFile(CallbackFileSystem* Sender, + CbFsFileInfo* FileInfo, + LPCTSTR NewFileName); + + void ReadFile(CallbackFileSystem* Sender, + CbFsFileInfo* FileInfo, + PVOID FileHandleContext, + __int64 Position, + PVOID Buffer, + DWORD BytesToRead, + PDWORD BytesRead); + + void WriteFile(CallbackFileSystem* Sender, + CbFsFileInfo* FileInfo, + PVOID FileHandleContext, + __int64 Position, + PVOID Buffer, + DWORD BytesToWrite, + PDWORD BytesWritten); + + void IsDirectoryEmpty(CallbackFileSystem* Sender, + LPWSTR FileName, + LPBOOL IsEmpty); + + void StorageEjected(CallbackFileSystem* Sender); + + /** Blocks until device was ejected by user. */ + void WaitForEjection(); + + private: + static const DWORD kMaxFileNameLength = 32767; + + static const size_t kMaxVolumeLabelLength = 32; + + /** Print debug output to stdout. */ + static void DbgPrint(LPCWSTR format, ...); + + /** Output exception thrown by CBFS as string. */ + static std::string ECBFSErrorToString(ECBFSError& e); + + /** Maps XtreemFS return values to Windows specific ones. */ + static int ConvertXtreemFSErrnoToWindows( + xtreemfs::pbrpc::POSIXErrno xtreemfs_errno); + + /** Convert UNIX timestamp (in nanoseconds) to Windows time format. */ + static void XtreemFSTimeToWinTime(uint64_t utime_ns, + DWORD* lower, + DWORD* upper); + + /** Convert Windows timestamp to UNIX timestamp (in nanoseconds). */ + static boost::uint64_t ConvertWinTimeToXtreemFSTime(DWORD lower, + DWORD upper); + + /** Returns true if "stat" is a directory. */ + static bool IsDirectory(const xtreemfs::pbrpc::Stat& stat); + + /** Convert "desired_access", passed at Create and Open, to e.g., O_RDWR. */ + static xtreemfs::pbrpc::SYSTEM_V_FCNTL ConvertFlagsWindowsToXtreemFS( + const ACCESS_MASK desired_access); + + /** Provides the CBFS library the required license key. */ + void SetRegistrationKey(); + + /** Returns true if "path" is a directory. + * @throws AddressToUUIDNotFoundException + * @throws IOException + * @throws PosixErrorException + * @throws UnknownAddressSchemeException + */ + bool IsDirectory(const std::string& path); + + /** Same as GetFileInfo(), except that "path" is an UTF8 encoded UNIX path. */ + void ConvertXtreemFSStatToCbFS(const xtreemfs::pbrpc::Stat& stat, + PFILETIME CreationTime, + PFILETIME LastAccessTime, + PFILETIME LastWriteTime, + __int64* EndOfFile, + __int64* AllocationSize, + __int64* FileId, + PDWORD FileAttributes, + LPTSTR LongFileName OPTIONAL, + PWORD LongFileNameLength OPTIONAL); + + /** Contains all needed options to mount the requested volume. */ + CbFSOptions* options_; + + /** Volume Label generated from the given XtreemFS URL. */ + std::wstring volume_label_; + + /** The chosen UserMapping provides methods to translate between local and + * remote usernames and groups. */ + boost::scoped_ptr system_user_mapping_; + + /** Username and domain name of user executing the Dokan client. Will be used + * by all XtreemFS operations. */ + xtreemfs::pbrpc::UserCredentials user_credentials_; + + /** Created libxtreemfs Client. */ + boost::scoped_ptr client_; + + /** Opened libxtreemfs Volume. */ + Volume* volume_; + + /** Server for processing commands sent from the xtfsutil tool + via xctl files. */ + XtfsUtilServer xctl_; + + /** Callback Filesystem instance which provides a Windows user space + * file system interface. */ + CallbackFileSystem cbfs_; + + /** True if device was ejected by user. */ + bool device_ejected_; + + /** Guards device_ejected_. */ + boost::mutex device_ejected_mutex_; + + /** Used when waiting for a change of device_ejected_. */ + boost::condition device_ejected_cond_; +}; + +} // namespace xtreemfs + +#endif // CPP_INCLUDE_CBFS_CBFS_ADAPTER_H_ diff --git a/cpp/include/cbfs/cbfs_enumeration_context.h b/cpp/include/cbfs/cbfs_enumeration_context.h new file mode 100644 index 0000000..dc10302 --- /dev/null +++ b/cpp/include/cbfs/cbfs_enumeration_context.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2012 by Michael Berlin, Zuse Institute Berlin + * + * Licensed under the BSD License, see LICENSE file for details. + * + */ + +#ifndef CPP_INCLUDE_CBFS_CBFS_ENUMERATION_CONTEXT_H_ +#define CPP_INCLUDE_CBFS_CBFS_ENUMERATION_CONTEXT_H_ + +#include + +namespace xtreemfs { + +namespace pbrpc { + +class DirectoryEntries; + +} // namespace pbrpc + +struct CbFSEnumerationContext { + CbFSEnumerationContext(); + + ~CbFSEnumerationContext(); + + /** Index in the complete directory listing where dir_entries starts. */ + boost::uint64_t offset; + xtreemfs::pbrpc::DirectoryEntries* dir_entries; + /** Index of next entry which will be returned from dir_entries (starting from + * 0). + * + * @attention This is relative to dir_entries, not to the complete dir. + */ + int next_index; +}; + +} // namespace xtreemfs + +#endif // CPP_INCLUDE_CBFS_CBFS_ENUMERATION_CONTEXT_H_ diff --git a/cpp/include/cbfs/cbfs_options.h b/cpp/include/cbfs/cbfs_options.h new file mode 100644 index 0000000..b2d8115 --- /dev/null +++ b/cpp/include/cbfs/cbfs_options.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2012 by Michael Berlin, Zuse Institute Berlin + * + * Licensed under the BSD License, see LICENSE file for details. + * + */ + +#ifndef CPP_INCLUDE_CBFS_CBFS_OPTIONS_H_ +#define CPP_INCLUDE_CBFS_CBFS_OPTIONS_H_ + +#include "libxtreemfs/options.h" + +#include +#include +#include + +namespace xtreemfs { + +class CbFSOptions : public Options { + public: + /** Sets the default values. */ + CbFSOptions(); + + /** Set options parsed from command line which must contain at least the URL + * to a XtreemFS volume and a mount point. + * + * Calls Options::ParseCommandLine() to parse general options. + * + * @throws InvalidCommandLineParametersException + * @throws InvalidURLException */ + void ParseCommandLine(int argc, char** argv); + + /** Shows only the minimal help text describing the usage of mount.xtreemfs.*/ + std::string ShowCommandLineUsage(); + + /** Outputs usage of the command line parameters. */ + virtual std::string ShowCommandLineHelp(); + + // CbFS options. + + private: + /** Contains all available CbFS options and its descriptions. */ + boost::program_options::options_description cbfs_descriptions_; + + /** Brief help text if there are no command line arguments. */ + std::string helptext_usage_; +}; + +} // namespace xtreemfs + +#endif // CPP_INCLUDE_CBFS_CBFS_OPTIONS_H_ diff --git a/cpp/include/fuse/cached_directory_entries.h b/cpp/include/fuse/cached_directory_entries.h new file mode 100644 index 0000000..729246b --- /dev/null +++ b/cpp/include/fuse/cached_directory_entries.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2011 by Michael Berlin, Zuse Institute Berlin + * + * Licensed under the BSD License, see LICENSE file for details. + * + */ + +#ifndef CPP_INCLUDE_FUSE_CACHED_DIRECTORY_ENTRIES_H_ +#define CPP_INCLUDE_FUSE_CACHED_DIRECTORY_ENTRIES_H_ + +#include + +#include + +namespace xtreemfs { + +namespace pbrpc { + +class DirectoryEntries; + +} // namespace pbrpc + +struct CachedDirectoryEntries { + uint64_t offset; + xtreemfs::pbrpc::DirectoryEntries* dir_entries; + boost::mutex mutex; +}; + +} // namespace xtreemfs + +#endif // CPP_INCLUDE_FUSE_CACHED_DIRECTORY_ENTRIES_H_ diff --git a/cpp/include/fuse/fuse_adapter.h b/cpp/include/fuse/fuse_adapter.h new file mode 100644 index 0000000..b00de48 --- /dev/null +++ b/cpp/include/fuse/fuse_adapter.h @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2011 by Michael Berlin, Zuse Institute Berlin + * + * Licensed under the BSD License, see LICENSE file for details. + * + */ + +#ifndef CPP_INCLUDE_FUSE_FUSE_ADAPTER_H_ +#define CPP_INCLUDE_FUSE_FUSE_ADAPTER_H_ + +#include +#define FUSE_USE_VERSION 26 +#include + +#include +#include +#include + +#include "libxtreemfs/system_user_mapping_unix.h" +#include "xtfsutil/xtfsutil_server.h" +#include "xtreemfs/GlobalTypes.pb.h" + +namespace xtreemfs { +class Client; +class FuseOptions; +class UserMapping; +class Volume; + +namespace pbrpc { +class Stat; +class UserCredentials; +} // namespace pbrpc + +/** Uses fuse_interrupted() to check if an operation was cancelled by the user + * and stops retrying to execute the request then. + * + * Always returns 0, if called from a non-Fuse thread. */ +int CheckIfOperationInterrupted(); + +class FuseAdapter { + public: + /** Creates a new instance of FuseAdapter, but does not create any libxtreemfs + * Client yet. + * + * Use Start() to actually create the client and mount the volume given in + * options. May modify options. + */ + explicit FuseAdapter(FuseOptions* options); + + ~FuseAdapter(); + + /** Create client, open volume and start needed threads. + * @return Returns a list of additional "-o