diff --git a/.gitignore b/.gitignore
index b3a5a5a9638f468269772d516eac8e35cf44450f..7d29fc82d7496155f5a3057e548866c4b181f054 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,6 @@
/.googletest_library_already_built
.idea
*.iml
+/java/flease/nbproject/private/
+/java/pbrpcgen/nbproject/private/
+/java/pbrpcgen/dist/
\ No newline at end of file
diff --git a/AUTHORS b/AUTHORS
index 532c674d227ba83f2622e754484e77656c4aa629..b91d316a80c6c31c2b2f93f6cb7cc5711d9cd2a3 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -4,6 +4,7 @@ Johannes Dillmann
Jens V. Fischer
Juan Gonzalez
Lukas Kairies
+Christoph Kleineweber
Björn Kolbeck
Nico Kruber
Felix Langner
diff --git a/CHANGELOG b/CHANGELOG
index c7694e8d812a3afe5f4b3d5f00c723f5ffde3956..3ee0582b44dd264a2fe404b9f8bcbff338150498 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,24 @@
+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:
diff --git a/Makefile b/Makefile
index 498291dce3c71c523242ed2e6cebb968b47bc39f..6e29101bdd5889f01129124c2c7a423ecd2cdbba 100644
--- a/Makefile
+++ b/Makefile
@@ -43,7 +43,7 @@ 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.3.0
+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.5.0
CLIENT_GOOGLE_TEST_CPP_LIBRARY = $(CLIENT_GOOGLE_TEST_CPP)/lib/.libs/libgtest.a
@@ -67,17 +67,18 @@ install: install-client install-server install-tools
install-client:
- @if [ ! -f $(XTREEMFS_BINARIES_DIR)/mount.xtreemfs ]; then echo "PLEASE RUN 'make client' FIRST!"; exit 1; fi
+ @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)
-
- @mkdir -p $(SBIN_DIR)
- @ln -s $(BIN_DIR)/mount.xtreemfs $(SBIN_DIR)/mount.xtreemfs
- @ln -s $(BIN_DIR)/umount.xtreemfs $(SBIN_DIR)/umount.xtreemfs
+
+# 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)
@@ -102,7 +103,7 @@ install-server:
@mkdir -p $(XTREEMFS_CONFIG_DIR)
# @cp etc/xos/xtreemfs/*config.properties $(XTREEMFS_CONFIG_DIR)
- # delete UUID from config-files
+# 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
@@ -115,8 +116,10 @@ install-server:
@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-* $(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)
@@ -156,8 +159,14 @@ uninstall:
@rm -f $(SBIN_DIR)/umount.xtreemfs
@rm -f $(XTREEMFS_JAR_DIR)/XtreemFS.jar
- @rm -f $(XTREEMFS_JAR_DIR)/BabuDB*.jar
- @rm -f $(XTREEMFS_JAR_DIR)/yidl.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-*
@@ -209,12 +218,16 @@ endif
ifdef BOOST_ROOT
CMAKE_BOOST_ROOT = -DBOOST_ROOT="$(BOOST_ROOT)"
endif
+# Tell CMake if it should ignore a missing Fuse.
+ifdef SKIP_FUSE
+ CMAKE_SKIP_FUSE = -DSKIP_FUSE=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) && ./configure $(PROTOBUF_DISABLE_64_BIT_SOLARIS) >/dev/null
+ @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)
@@ -251,7 +264,7 @@ 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_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)
@$(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)
diff --git a/bin/protoc-gen-pbrpc b/bin/protoc-gen-pbrpc
index 55143b00e8c5d138a380eee62e51f68ca5a342f9..75ba193062b0e3b8dcb1c7a799ce1f68bfd41191 100755
--- a/bin/protoc-gen-pbrpc
+++ b/bin/protoc-gen-pbrpc
@@ -1,4 +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.3.0.jar org.xtreemfs.pbrpcgen.RPCSourceGenerator
+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
index 6e230c2822813b2bfeaf0c654fe66b56b2748587..44a8aaf98f239e939217b4981eee3f43e4613e11 100755
--- a/bin/protoc-gen-pbrpccpp
+++ b/bin/protoc-gen-pbrpccpp
@@ -1,4 +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.3.0.jar org.xtreemfs.pbrpcgen.RPCCPPSourceGenerator
+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/xtfs_chstatus b/bin/xtfs_chstatus
index 6a7dc306b24f29bb4c471e0bcb6ef463ed4c3b54..d269100811128a16be65c8845709e6ad11bee459 100755
--- a/bin/xtfs_chstatus
+++ b/bin/xtfs_chstatus
@@ -42,5 +42,5 @@ check_java() {
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.3.0.jar:/usr/share/java/Foundation.jar:. \
+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
index 4d4e8f32e08d8453adf32c48e3e5d880b0dad567..2ca30132572d03e24c8068af8373fa095cc1f864 100755
--- a/bin/xtfs_cleanup
+++ b/bin/xtfs_cleanup
@@ -42,5 +42,5 @@ check_java() {
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.3.0.jar:/usr/share/java/Foundation.jar:. \
+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
index 4287860c66c7c900784b947db523a7fb5eb847dc..7a5502f776f0cc70ddffad45168325a05d0ce729 100755
--- a/bin/xtfs_mrcdbtool
+++ b/bin/xtfs_mrcdbtool
@@ -42,5 +42,5 @@ check_java() {
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.3.0.jar:/usr/share/java/Foundation.jar:. \
+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
index e2691e87ac1c03c656838d0861bfee87dd4bbc64..e68f193309d92fa58798fd720e1365558afafd01 100755
--- a/bin/xtfs_remove_osd
+++ b/bin/xtfs_remove_osd
@@ -42,5 +42,5 @@ check_java() {
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.3.0.jar:/usr/share/java/Foundation.jar:. \
+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
index 68b81fac0844b2cf9a68088db0c306b2eda15851..718319c5b96f04e61e5c7326685f4cb8bde9a7e1 100755
--- a/bin/xtfs_scrub
+++ b/bin/xtfs_scrub
@@ -42,5 +42,5 @@ check_java() {
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.3.0.jar:/usr/share/java/Foundation.jar:. \
+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/hadoop/build.xml b/contrib/hadoop/build.xml
index c4d7c266575cfe727d622d9d3d7814310d0d84d9..c85282cbd1c230e2b18b619b155261acd72be6f8 100644
--- a/contrib/hadoop/build.xml
+++ b/contrib/hadoop/build.xml
@@ -85,7 +85,7 @@
-
+
diff --git a/contrib/hadoop/nbproject/project.properties b/contrib/hadoop/nbproject/project.properties
index cdb70b400acbf1e08042f84db45274d75b8d5053..7da24ad5d23ba506bf9ea68f31b0f770ffd55421 100644
--- a/contrib/hadoop/nbproject/project.properties
+++ b/contrib/hadoop/nbproject/project.properties
@@ -27,7 +27,7 @@ endorsed.classpath=
excludes=
file.reference.Foundation.jar=../../java/foundation/dist/Foundation.jar
file.reference.hadoop-core-1.0.1.jar=lib/hadoop-core-1.0.1.jar
-file.reference.protobuf-java-2.3.0.jar=../../java/lib/protobuf-java-2.3.0.jar
+file.reference.protobuf-java-2.5.0.jar=../../java/lib/protobuf-java-2.5.0.jar
file.reference.XtreemFS.jar=../../java/servers/dist/XtreemFS.jar
includes=**
jar.archive.disabled=${jnlp.enabled}
@@ -35,7 +35,7 @@ jar.compress=false
jar.index=${jnlp.enabled}
javac.classpath=\
${file.reference.Foundation.jar}:\
- ${file.reference.protobuf-java-2.3.0.jar}:\
+ ${file.reference.protobuf-java-2.5.0.jar}:\
${file.reference.XtreemFS.jar}:\
${file.reference.hadoop-core-1.0.1.jar}
diff --git a/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileOutputStream.java b/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileOutputStream.java
index 8579ea526296763c0967d1cd9f6f092fe51e7279..5cb481c25754d18ab233b601ad1441e9df854d2f 100644
--- a/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileOutputStream.java
+++ b/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileOutputStream.java
@@ -8,6 +8,7 @@ package org.xtreemfs.common.clients.hadoop;
import java.io.IOException;
import java.io.OutputStream;
+import java.nio.ByteBuffer;
import org.xtreemfs.common.libxtreemfs.FileHandle;
import org.xtreemfs.foundation.logging.Logging;
@@ -18,7 +19,7 @@ import org.xtreemfs.foundation.pbrpc.generatedinterfaces.RPC.UserCredentials;
* Represents an Outputstream used when writing a file with HDFS.
*/
public class XtreemFSFileOutputStream extends OutputStream {
- private int position = 0;
+ private long position = 0;
private UserCredentials userCredentials;
@@ -26,32 +27,50 @@ public class XtreemFSFileOutputStream extends OutputStream {
private String fileName;
- public XtreemFSFileOutputStream(UserCredentials userCredentials, FileHandle fileHandle, String fileName) {
+ private boolean useBuffer;
+
+ private ByteBuffer buffer;
+
+ public XtreemFSFileOutputStream(UserCredentials userCredentials, FileHandle fileHandle, String fileName,
+ boolean useBuffer, int bufferSize) {
this.userCredentials = userCredentials;
this.fileHandle = fileHandle;
this.fileName = fileName;
+ this.useBuffer = useBuffer;
+ if (useBuffer) {
+ this.buffer = ByteBuffer.allocateDirect(bufferSize);
+ }
}
@Override
public synchronized void write(int b) throws IOException {
byte[] data = new byte[1];
data[0] = (byte) b;
- int writtenBytes = fileHandle.write(userCredentials, data, 1, position);
- position += writtenBytes;
+ if (useBuffer) {
+ writeToBuffer(data, 0, 1);
+ } else {
+ int writtenBytes = fileHandle.write(userCredentials, data, 1, position);
+ position += writtenBytes;
+ }
+
}
@Override
public synchronized void write(byte b[], int off, int len) throws IOException {
if (b == null) {
throw new NullPointerException();
- } else if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length)
- || ((off + len) < 0)) {
+ } else if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return;
}
- int writtenBytes = fileHandle.write(userCredentials, b, off, len, position);
- position += writtenBytes;
+
+ if (useBuffer) {
+ writeToBuffer(b, off, len);
+ } else {
+ int writtenBytes = fileHandle.write(userCredentials, b, off, len, position);
+ position += writtenBytes;
+ }
}
@Override
@@ -59,8 +78,40 @@ public class XtreemFSFileOutputStream extends OutputStream {
if (Logging.isDebug()) {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "Closing file %s", fileName);
}
+
+ if (useBuffer && buffer.position() > 0) {
+ // If buffer has remaining content, write content to file.
+ byte[] bytesWriteToFile = flushBuffer();
+ fileHandle.write(userCredentials, bytesWriteToFile, bytesWriteToFile.length, position);
+ buffer = null;
+ }
super.close();
fileHandle.close();
}
+ private synchronized void writeToBuffer(byte b[], int off, int len) throws IOException {
+ if (buffer.remaining() > len) {
+ // Write content to buffer.
+ buffer.put(b, off, len);
+ } else {
+ // Flush buffer and write content + last write request to file.
+ byte[] buffercontent = flushBuffer();
+ byte[] bytesWriteToFile = new byte[buffercontent.length + len];
+ System.arraycopy(buffercontent, 0, bytesWriteToFile, 0, buffercontent.length);
+ System.arraycopy(b, off, bytesWriteToFile, buffercontent.length, len);
+ int writtenBytes = fileHandle
+ .write(userCredentials, bytesWriteToFile, bytesWriteToFile.length, position);
+ position += writtenBytes;
+ }
+ }
+
+ private byte[] flushBuffer() {
+ int bytesInBuffer = buffer.position();
+ buffer.clear();
+ byte[] buffercontent = new byte[bytesInBuffer];
+ buffer.get(buffercontent, 0, bytesInBuffer);
+ buffer.clear();
+ return buffercontent;
+ }
+
}
diff --git a/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileSystem.java b/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileSystem.java
index 60bfc1b7e75b9985377a4069c97a9b7dbbf8b57a..f493a30f2c0ad79271f21b67ce7821887dc61920 100644
--- a/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileSystem.java
+++ b/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileSystem.java
@@ -11,7 +11,11 @@ import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
+import java.util.Map;
+import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -48,19 +52,24 @@ import org.xtreemfs.pbrpc.generatedinterfaces.MRC.Stat;
*/
public class XtreemFSFileSystem extends FileSystem {
- private URI fileSystemURI;
- private Client xtreemfsClient;
- private Volume xtreemfsVolume;
- private Path workingDirectory;
- private UserCredentials userCredentials;
- private long stripeSize;
+ private URI fileSystemURI;
+ private Client xtreemfsClient;
+ private Map xtreemfsVolumes;
+ Set defaultVolumeDirectories;
+ private Path workingDirectory;
+ private UserCredentials userCredentials;
+ private boolean useReadBuffer;
+ private boolean useWriteBuffer;
+ private int readBufferSize;
+ private int writeBufferSize;
+ private Volume defaultVolume;
@Override
public void initialize(URI uri, Configuration conf) throws IOException {
super.initialize(uri, conf);
int logLevel = Logging.LEVEL_WARN;
- if (conf.getBoolean("xtreemfs.client.debug", true)) {
+ if (conf.getBoolean("xtreemfs.client.debug", false)) {
logLevel = Logging.LEVEL_DEBUG;
}
@@ -69,64 +78,86 @@ public class XtreemFSFileSystem extends FileSystem {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "init : " + uri);
}
- String volumeName = conf.get("xtreemfs.volumeName");
- if (volumeName == null) {
- throw new IOException("You have to specify a volume name in"
- + " core-site.xml! (xtreemfs.volumeName)");
+ String defaultVolumeName = conf.get("xtreemfs.defaultVolumeName");
+
+ if (defaultVolumeName == null) {
+ throw new IOException("You have to specify a default volume name in"
+ + " core-site.xml! (xtreemfs.defaultVolumeName)");
+ }
+
+ useReadBuffer = conf.getBoolean("xtreemfs.io.buffer.read", false);
+ readBufferSize = conf.getInt("xtreemfs.io.buffer.size.read", 0);
+ if (useReadBuffer && readBufferSize == 0) {
+ useReadBuffer = false;
+ }
+
+ useWriteBuffer = conf.getBoolean("xtreemfs.io.buffer.write", false);
+ writeBufferSize = conf.getInt("xtreemfs.io.buffer.size.write", 0);
+ if (useWriteBuffer && writeBufferSize == 0) {
+ useWriteBuffer = false;
}
// create UserCredentials
if ((conf.get("xtreemfs.client.userid") != null) && (conf.get("xtreemfs.client.groupid") != null)) {
- userCredentials =
- UserCredentials.newBuilder().setUsername(conf.get("xtreemfs.client.userid"))
- .addGroups(conf.get("xtreemfs.client.groupid")).build();
+ userCredentials = UserCredentials.newBuilder().setUsername(conf.get("xtreemfs.client.userid"))
+ .addGroups(conf.get("xtreemfs.client.groupid")).build();
}
if (userCredentials == null) {
if (System.getProperty("user.name") != null) {
- userCredentials =
- UserCredentials.newBuilder().setUsername(System.getProperty("user.name"))
- .addGroups("users").build();
+ userCredentials = UserCredentials.newBuilder().setUsername(System.getProperty("user.name"))
+ .addGroups("users").build();
} else {
- userCredentials =
- UserCredentials.newBuilder().setUsername("xtreemfs").addGroups("xtreemfs").build();
+ userCredentials = UserCredentials.newBuilder().setUsername("xtreemfs").addGroups("xtreemfs").build();
}
}
// initialize XtreemFS Client with default Options and without SSL.
Options xtreemfsOptions = new Options();
xtreemfsOptions.setMetadataCacheSize(0);
- xtreemfsClient =
- ClientFactory.createClient(uri.getHost() + ":" + uri.getPort(), userCredentials,
- xtreemfsOptions.generateSSLOptions(), xtreemfsOptions);
+ xtreemfsClient = ClientFactory.createClient(uri.getHost() + ":" + uri.getPort(), userCredentials,
+ xtreemfsOptions.generateSSLOptions(), xtreemfsOptions);
try {
// TODO: Fix stupid Exception in libxtreemfs
- xtreemfsClient.start();
+ xtreemfsClient.start(true);
} catch (Exception ex) {
Logger.getLogger(XtreemFSFileSystem.class.getName()).log(Level.SEVERE, null, ex);
}
- try {
- xtreemfsVolume = xtreemfsClient.openVolume(volumeName, null, xtreemfsOptions);
- } catch (VolumeNotFoundException ve) {
- Logging.logMessage(Logging.LEVEL_ERROR, Logging.Category.misc, this,
- "Unable to open volume %s. Make sure this volume exists!", volumeName);
- throw new IOException("Unable to open volume " + volumeName);
- } catch (AddressToUUIDNotFoundException aue) {
- Logging.logMessage(Logging.LEVEL_ERROR, Logging.Category.misc, this,
- "Unable to resolve UUID for volumeName %s", volumeName);
- throw new IOException(aue);
- } catch (Exception e) {
- e.printStackTrace();
+ // Get all available volumes.
+ String[] volumeNames = xtreemfsClient.listVolumeNames();
+
+ xtreemfsVolumes = new HashMap(volumeNames.length);
+ for (String volumeName : volumeNames) {
+ try {
+ xtreemfsVolumes.put(volumeName, xtreemfsClient.openVolume(volumeName, null, xtreemfsOptions));
+ } catch (VolumeNotFoundException ve) {
+ Logging.logMessage(Logging.LEVEL_ERROR, Logging.Category.misc, this,
+ "Unable to open volume %s. Make sure this volume exists!", volumeName);
+ throw new IOException("Unable to open volume " + volumeName);
+ } catch (AddressToUUIDNotFoundException aue) {
+ Logging.logMessage(Logging.LEVEL_ERROR, Logging.Category.misc, this,
+ "Unable to resolve UUID for volumeName %s", volumeName);
+ throw new IOException(aue);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ // Get directories in root of defaultVolume.
+ defaultVolumeDirectories = new HashSet();
+ defaultVolume = xtreemfsVolumes.get(defaultVolumeName);
+ for (DirectoryEntry dirEntry : defaultVolume.readDir(userCredentials, "/", 0, 0, true).getEntriesList()) {
+ if (isXtreemFSDirectory("/" + dirEntry.getName(), defaultVolume)) {
+ defaultVolumeDirectories.add(dirEntry.getName());
+ }
}
- stripeSize = xtreemfsVolume.statFS(userCredentials).getDefaultStripingPolicy().getStripeSize();
- stripeSize *= 1024;
fileSystemURI = uri;
workingDirectory = getHomeDirectory();
if (Logging.isDebug()) {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "file system init complete: " + uri.getUserInfo());
- }
+ }
}
@Override
@@ -136,34 +167,32 @@ public class XtreemFSFileSystem extends FileSystem {
@Override
public FSDataInputStream open(Path path, int bufferSize) throws IOException {
- final String pathString = makeAbsolute(path).toUri().getPath();
- final FileHandle fileHandle =
- xtreemfsVolume.openFile(userCredentials, pathString,
- SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDONLY.getNumber(), 0);
+ Volume xtreemfsVolume = getVolumeFromPath(path);
+ final String pathString = preparePath(path, xtreemfsVolume);
+ final FileHandle fileHandle = xtreemfsVolume.openFile(userCredentials, pathString,
+ SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDONLY.getNumber(), 0);
if (Logging.isDebug()) {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "Opening file %s", pathString);
}
statistics.incrementReadOps(1);
-
- return new FSDataInputStream(new XtreemFSInputStream(userCredentials, fileHandle, pathString,
- statistics));
+ return new FSDataInputStream(new XtreemFSInputStream(userCredentials, fileHandle, pathString, useReadBuffer,
+ readBufferSize, statistics));
}
@Override
- public FSDataOutputStream create(Path path, FsPermission fp, boolean overwrite, int bufferSize,
- short replication, long blockSize, Progressable p) throws IOException {
+ public FSDataOutputStream create(Path path, FsPermission fp, boolean overwrite, int bufferSize, short replication,
+ long blockSize, Progressable p) throws IOException {
// block replication for the file
- final String pathString = makeAbsolute(path).toUri().getPath();
- int flags =
- SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber()
- | SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber();
+ Volume xtreemfsVolume = getVolumeFromPath(path);
+ final String pathString = preparePath(path, xtreemfsVolume);
+ int flags = SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_RDWR.getNumber()
+ | SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_CREAT.getNumber();
if (overwrite) {
flags |= SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_O_TRUNC.getNumber();
}
if (Logging.isDebug()) {
- Logging.logMessage(Logging.LEVEL_DEBUG, this, "Creating file %s. Overwrite = %s", pathString,
- overwrite);
+ Logging.logMessage(Logging.LEVEL_DEBUG, this, "Creating file %s. Overwrite = %s", pathString, overwrite);
}
// If some of the parent directories don't exist they should be created.
@@ -172,17 +201,16 @@ public class XtreemFSFileSystem extends FileSystem {
for (int i = 0; i < dirs.length - 1; i++) {
if (dirs[i].isEmpty() == false) {
tempPath = tempPath + "/" + dirs[i];
- if (isXtreemFSDirectory(tempPath) == false) {
+ if (isXtreemFSDirectory(tempPath, xtreemfsVolume) == false) {
xtreemfsVolume.createDirectory(userCredentials, tempPath, fp.toShort());
}
}
}
- final FileHandle fileHandle =
- xtreemfsVolume.openFile(userCredentials, pathString, flags, fp.toShort());
+ final FileHandle fileHandle = xtreemfsVolume.openFile(userCredentials, pathString, flags, fp.toShort());
statistics.incrementWriteOps(1);
- return new FSDataOutputStream(new XtreemFSFileOutputStream(userCredentials, fileHandle, pathString),
- statistics);
+ return new FSDataOutputStream(new XtreemFSFileOutputStream(userCredentials, fileHandle, pathString,
+ useWriteBuffer, writeBufferSize), statistics);
}
@Override
@@ -192,12 +220,13 @@ public class XtreemFSFileSystem extends FileSystem {
@Override
public boolean rename(Path src, Path dest) throws IOException {
- final String srcPath = makeAbsolute(src).toUri().getPath();
- final String destPath = makeAbsolute(dest).toUri().getPath();
+ Volume xtreemfsVolume = getVolumeFromPath(src);
+ final String srcPath = preparePath(src, xtreemfsVolume);
+ final String destPath = preparePath(dest, xtreemfsVolume);
+
xtreemfsVolume.rename(userCredentials, srcPath, destPath);
if (Logging.isDebug()) {
- Logging.logMessage(Logging.LEVEL_DEBUG, this, "Renamed file/dir. src: %s, dst: %s", srcPath,
- destPath);
+ Logging.logMessage(Logging.LEVEL_DEBUG, this, "Renamed file/dir. src: %s, dst: %s", srcPath, destPath);
}
statistics.incrementWriteOps(1);
return true;
@@ -211,29 +240,30 @@ public class XtreemFSFileSystem extends FileSystem {
@Override
public boolean delete(Path path, boolean recursive) throws IOException {
statistics.incrementWriteOps(1);
- final String pathString = makeAbsolute(path).toUri().getPath();
- if (isXtreemFSFile(pathString)) {
+ Volume xtreemfsVolume = getVolumeFromPath(path);
+ final String pathString = preparePath(path, xtreemfsVolume);
+ if (isXtreemFSFile(pathString, xtreemfsVolume)) {
if (Logging.isDebug()) {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "Deleting file %s", pathString);
}
- return deleteXtreemFSFile(pathString);
+ return deleteXtreemFSFile(pathString, xtreemfsVolume);
}
- if (isXtreemFSDirectory(pathString)) {
+ if (isXtreemFSDirectory(pathString, xtreemfsVolume)) {
if (Logging.isDebug()) {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "Deleting directory %s", pathString);
}
- return deleteXtreemFSDirectory(pathString, recursive);
+ return deleteXtreemFSDirectory(pathString, xtreemfsVolume, recursive);
}
// path is neither a file nor a directory. Consider it as not existing.
return false;
}
- private boolean deleteXtreemFSDirectory(String path, boolean recursive) throws IOException {
+ private boolean deleteXtreemFSDirectory(String path, Volume xtreemfsVolume, boolean recursive) throws IOException {
DirectoryEntries dirEntries = xtreemfsVolume.readDir(userCredentials, path, 0, 0, true);
boolean isEmpty = (dirEntries.getEntriesCount() <= 2);
if (recursive) {
- return deleteXtreemFSDirRecursive(path);
+ return deleteXtreemFSDirRecursive(path, xtreemfsVolume);
} else {
if (isEmpty) {
xtreemfsVolume.removeDirectory(userCredentials, path);
@@ -244,7 +274,7 @@ public class XtreemFSFileSystem extends FileSystem {
}
}
- private boolean deleteXtreemFSDirRecursive(String path) throws IOException {
+ private boolean deleteXtreemFSDirRecursive(String path, Volume xtreemfsVolume) throws IOException {
boolean success = true;
try {
DirectoryEntries dirEntries = xtreemfsVolume.readDir(userCredentials, path, 0, 0, false);
@@ -256,7 +286,7 @@ public class XtreemFSFileSystem extends FileSystem {
xtreemfsVolume.unlink(userCredentials, path + "/" + dirEntry.getName());
}
if (isXtreemFSDirectory(dirEntry.getStbuf())) {
- success = deleteXtreemFSDirRecursive(path + "/" + dirEntry.getName());
+ success = deleteXtreemFSDirRecursive(path + "/" + dirEntry.getName(), xtreemfsVolume);
}
}
xtreemfsVolume.removeDirectory(userCredentials, path);
@@ -266,7 +296,7 @@ public class XtreemFSFileSystem extends FileSystem {
return success;
}
- private boolean deleteXtreemFSFile(String path) throws IOException {
+ private boolean deleteXtreemFSFile(String path, Volume xtreemfsVolume) throws IOException {
try {
xtreemfsVolume.unlink(userCredentials, path);
return true;
@@ -277,7 +307,7 @@ public class XtreemFSFileSystem extends FileSystem {
}
}
- private boolean isXtreemFSFile(String path) throws IOException {
+ private boolean isXtreemFSFile(String path, Volume xtreemfsVolume) throws IOException {
Stat stat = null;
try {
stat = xtreemfsVolume.getAttr(userCredentials, path);
@@ -299,7 +329,7 @@ public class XtreemFSFileSystem extends FileSystem {
return (stat.getMode() & SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_S_IFREG.getNumber()) > 0;
}
- private boolean isXtreemFSDirectory(String path) throws IOException {
+ private boolean isXtreemFSDirectory(String path, Volume xtreemfsVolume) throws IOException {
Stat stat = null;
try {
stat = xtreemfsVolume.getAttr(userCredentials, path);
@@ -326,13 +356,14 @@ public class XtreemFSFileSystem extends FileSystem {
if (path == null) {
return null;
}
+ Volume xtreemfsVolume = getVolumeFromPath(path);
+ final String pathString = preparePath(path, xtreemfsVolume);
- final String pathString = makeAbsolute(path).toUri().getPath();
if (Logging.isDebug()) {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "ls: " + pathString);
}
- if (isXtreemFSDirectory(pathString) == false) {
+ if (isXtreemFSDirectory(pathString, xtreemfsVolume) == false) {
return null;
}
@@ -348,14 +379,14 @@ public class XtreemFSFileSystem extends FileSystem {
if (isDir) {
// for directories, set blocksize to 0
fileStatus.add(new FileStatus(0, isDir, 1, 0, (long) (stat.getMtimeNs() / 1e6), (long) (stat
- .getAtimeNs() / 1e6), new FsPermission((short) stat.getMode()), stat.getUserId(),
- stat.getGroupId(), new Path(makeAbsolute(path), entry.getName())));
+ .getAtimeNs() / 1e6), new FsPermission((short) stat.getMode()), stat.getUserId(), stat
+ .getGroupId(), new Path(makeAbsolute(path), entry.getName())));
} else {
// for files, set blocksize to stripeSize of the volume
- fileStatus.add(new FileStatus(stat.getSize(), isDir, 1, stripeSize,
- (long) (stat.getMtimeNs() / 1e6), (long) (stat.getAtimeNs() / 1e6), new FsPermission(
- (short) stat.getMode()), stat.getUserId(), stat.getGroupId(), new Path(
- makeAbsolute(path), entry.getName())));
+ fileStatus.add(new FileStatus(stat.getSize(), isDir, 1, xtreemfsVolume.statFS(userCredentials)
+ .getDefaultStripingPolicy().getStripeSize() * 1024, (long) (stat.getMtimeNs() / 1e6),
+ (long) (stat.getAtimeNs() / 1e6), new FsPermission((short) stat.getMode()), stat.getUserId(),
+ stat.getGroupId(), new Path(makeAbsolute(path), entry.getName())));
}
}
return fileStatus.toArray(new FileStatus[fileStatus.size()]);
@@ -363,7 +394,14 @@ public class XtreemFSFileSystem extends FileSystem {
@Override
public void setWorkingDirectory(Path path) {
- this.workingDirectory = makeAbsolute(path);
+ Volume xtreemfsVolume = null;
+ try {
+ xtreemfsVolume = getVolumeFromPath(path);
+ this.workingDirectory = new Path(preparePath(path, xtreemfsVolume));
+ } catch (IOException e) {
+ Logging.logMessage(Logging.LEVEL_ERROR, Logging.Category.misc, this,
+ "Unable to set working directory. %s does not exist!", makeAbsolute(path).toUri().toString());
+ }
}
@Override
@@ -381,18 +419,24 @@ public class XtreemFSFileSystem extends FileSystem {
@Override
public boolean mkdirs(Path path, FsPermission fp) throws IOException {
- final String pathString = makeAbsolute(path).toUri().getPath();
+ Volume xtreemfsVolume = getVolumeFromPath(path);
+ final String pathString = preparePath(path, xtreemfsVolume);
final String[] dirs = pathString.split("/");
statistics.incrementWriteOps(1);
final short mode = fp.toShort();
String dirString = "";
+
+ if (xtreemfsVolume == defaultVolume) {
+ defaultVolumeDirectories.add(dirs[0]);
+ }
+
for (String dir : dirs) {
dirString += dir + "/";
- if (isXtreemFSFile(dirString)) {
+ if (isXtreemFSFile(dirString, xtreemfsVolume)) {
return false;
}
- if (isXtreemFSDirectory(dirString) == false) { // stringPath does not exist, create it
+ if (isXtreemFSDirectory(dirString, xtreemfsVolume) == false) { // stringPath does not exist, create it
xtreemfsVolume.createDirectory(userCredentials, dirString, mode);
}
}
@@ -404,7 +448,8 @@ public class XtreemFSFileSystem extends FileSystem {
@Override
public FileStatus getFileStatus(Path path) throws IOException {
- final String pathString = makeAbsolute(path).toUri().getPath();
+ Volume xtreemfsVolume = getVolumeFromPath(path);
+ final String pathString = preparePath(path, xtreemfsVolume);
if (Logging.isDebug()) {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "getting file status for file %s", pathString);
}
@@ -420,14 +465,14 @@ public class XtreemFSFileSystem extends FileSystem {
final boolean isDir = isXtreemFSDirectory(stat);
if (isDir) {
// for directories, set blocksize to 0
- return new FileStatus(0, isDir, 1, 0, (long) (stat.getMtimeNs() / 1e6),
- (long) (stat.getAtimeNs() / 1e6), new FsPermission((short) stat.getMode()),
- stat.getUserId(), stat.getGroupId(), makeAbsolute(path));
+ return new FileStatus(0, isDir, 1, 0, (long) (stat.getMtimeNs() / 1e6), (long) (stat.getAtimeNs() / 1e6),
+ new FsPermission((short) stat.getMode()), stat.getUserId(), stat.getGroupId(), makeAbsolute(path));
} else {
// for files, set blocksize to stripesize of the volume
- return new FileStatus(stat.getSize(), isDir, 1, stripeSize, (long) (stat.getMtimeNs() / 1e6),
- (long) (stat.getAtimeNs() / 1e6), new FsPermission((short) stat.getMode()),
- stat.getUserId(), stat.getGroupId(), makeAbsolute(path));
+ return new FileStatus(stat.getSize(), isDir, 1, xtreemfsVolume.statFS(userCredentials)
+ .getDefaultStripingPolicy().getStripeSize() * 1024, (long) (stat.getMtimeNs() / 1e6),
+ (long) (stat.getAtimeNs() / 1e6), new FsPermission((short) stat.getMode()), stat.getUserId(),
+ stat.getGroupId(), makeAbsolute(path));
}
}
@@ -437,7 +482,9 @@ public class XtreemFSFileSystem extends FileSystem {
Logging.logMessage(Logging.LEVEL_DEBUG, this, "Closing %s", XtreemFSFileSystem.class.getName());
}
super.close();
- xtreemfsVolume.close();
+ for (Volume xtreemfsVolume : xtreemfsVolumes.values()) {
+ xtreemfsVolume.close();
+ }
xtreemfsClient.shutdown();
}
@@ -446,17 +493,62 @@ public class XtreemFSFileSystem extends FileSystem {
if (file == null) {
return null;
}
- String pathString = makeAbsolute(file.getPath()).toUri().getPath();
- List stripeLocations =
- xtreemfsVolume.getStripeLocations(userCredentials, pathString, start, length);
+ Volume xtreemfsVolume = getVolumeFromPath(file.getPath());
+ String pathString = preparePath(file.getPath(), xtreemfsVolume);
+ List stripeLocations = xtreemfsVolume.getStripeLocations(userCredentials, pathString, start,
+ length);
BlockLocation[] result = new BlockLocation[stripeLocations.size()];
for (int i = 0; i < result.length; ++i) {
- result[i] =
- new BlockLocation(stripeLocations.get(i).getUuids(), stripeLocations.get(i)
- .getHostnames(), stripeLocations.get(i).getStartSize(), stripeLocations.get(i)
- .getLength());
+ result[i] = new BlockLocation(stripeLocations.get(i).getUuids(), stripeLocations.get(i).getHostnames(),
+ stripeLocations.get(i).getStartSize(), stripeLocations.get(i).getLength());
}
return result;
}
+
+ /**
+ * Make path absolute and remove volume if path starts with a volume
+ *
+ * @param path
+ * @param volume
+ * @return
+ */
+ private String preparePath(Path path, Volume volume) {
+ String pathString = makeAbsolute(path).toUri().getPath();
+ if (volume == defaultVolume) {
+ return pathString;
+ } else {
+ int pathBegin = pathString.indexOf("/", 1);
+ String pathStringWithoutVolume = pathString.substring(pathBegin);
+ return pathStringWithoutVolume;
+ }
+ }
+
+ /**
+ * Returns the volume name from the path or the default volume, if the path does not contain a volume name or the
+ * default volume has a directory equally named to the volume.
+ *
+ * @param path
+ * @return
+ * @throws IOException
+ */
+ private Volume getVolumeFromPath(Path path) throws IOException {
+ String pathString = makeAbsolute(path).toUri().getPath();
+ String[] splittedPath = pathString.split("/");
+ if (splittedPath.length > 1 && defaultVolumeDirectories.contains(splittedPath[1]) || pathString.lastIndexOf("/") == 0) {
+ // First part of path is a directory or path is a file in the root of defaultVolume
+ return defaultVolume;
+ } else {
+ // First part of path is a volume
+ String volumeName = pathString.substring(1, pathString.indexOf("/", 1));
+ Volume volume = xtreemfsVolumes.get(volumeName);
+
+ if (volume == null) {
+ // If no volume or directory exist, assume a invalid path on default volume.
+ return defaultVolume;
+ } else {
+ return volume;
+ }
+ }
+ }
}
diff --git a/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSInputStream.java b/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSInputStream.java
index 86e12f82029a1b72c4e7e66696e57c8422f2baf4..3743618f1a3baaf0e1c19b638c3a2000b2369adf 100644
--- a/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSInputStream.java
+++ b/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSInputStream.java
@@ -6,6 +6,8 @@
*/
package org.xtreemfs.common.clients.hadoop;
+import java.io.File;
+import java.io.FileWriter;
import java.io.IOException;
import java.nio.ByteBuffer;
@@ -20,26 +22,45 @@ import org.xtreemfs.foundation.pbrpc.generatedinterfaces.RPC.UserCredentials;
*/
public class XtreemFSInputStream extends FSInputStream {
- private long position = 0;
+ private long position = 0;
+
+ // Used by the buffer to determine the position in the file.
+ private long bufferFilePosition = 0;
private UserCredentials userCredentials;
-
- private String fileName;
-
- private FileHandle fileHandle;
-
- private Statistics statistics;
-
- public XtreemFSInputStream(UserCredentials userCredentials, FileHandle fileHandle, String fileName, Statistics statistics) {
+
+ private String fileName;
+
+ private FileHandle fileHandle;
+
+ private Statistics statistics;
+
+ private boolean useBuffer;
+
+ private ByteBuffer buffer;
+
+ private boolean EOF = false;
+
+ public XtreemFSInputStream(UserCredentials userCredentials, FileHandle fileHandle, String fileName,
+ boolean useBuffer, int bufferSize, Statistics statistics) throws IOException {
this.userCredentials = userCredentials;
this.fileHandle = fileHandle;
this.fileName = fileName;
this.statistics = statistics;
+ this.useBuffer = useBuffer;
+ if (useBuffer) {
+ this.buffer = ByteBuffer.allocateDirect(bufferSize);
+ buffer.position(buffer.capacity());
+ }
}
@Override
public synchronized void seek(long l) throws IOException {
this.position = l;
+ if (useBuffer) {
+ this.bufferFilePosition = l;
+ buffer.position(buffer.limit());
+ }
}
@Override
@@ -54,30 +75,41 @@ public class XtreemFSInputStream extends FSInputStream {
@Override
public synchronized int read() throws IOException {
- byte[] buf = new byte[1];
- int numRead = fileHandle.read(userCredentials, buf, 1, (int) position);
- if (numRead == 0) {
+ byte[] data = new byte[1];
+ int bytesRead = 0;
+ if (useBuffer) {
+ bytesRead = readFromBuffer(data, 0, 1);
+ } else {
+ bytesRead = fileHandle.read(userCredentials, data, 1, position);
+ }
+
+ if (bytesRead == 0) {
return -1;
}
- seek(getPos() + 1);
+ position += 1;
statistics.incrementBytesRead(1);
- return (int) (buf[0] & 0xFF);
+ return (int) (data[0] & 0xFF);
}
@Override
public synchronized int read(byte[] bytes, int offset, int length) throws IOException {
- int bytesRead = fileHandle.read(userCredentials, bytes, offset, length, (int) getPos());
+ int bytesRead = 0;
+ if (useBuffer) {
+ bytesRead = readFromBuffer(bytes, offset, length);
+ } else {
+ bytesRead = fileHandle.read(userCredentials, bytes, offset, length, position);
+ }
if ((bytesRead == 0) && (length > 0)) {
return -1;
}
- seek(getPos() + bytesRead);
+ position += bytesRead;
statistics.incrementBytesRead(bytesRead);
return bytesRead;
}
@Override
public synchronized int read(long position, byte[] bytes, int offset, int length) throws IOException {
- int bytesRead = fileHandle.read(userCredentials, bytes, offset, length, (int) position);
+ int bytesRead = fileHandle.read(userCredentials, bytes, offset, length, position);
if ((bytesRead == 0) && (length > 0)) {
return -1;
}
@@ -87,7 +119,7 @@ public class XtreemFSInputStream extends FSInputStream {
@Override
public synchronized int read(byte[] bytes) throws IOException {
- return read(position, bytes, 0, bytes.length);
+ return read(bytes, 0, bytes.length);
}
@Override
@@ -98,4 +130,48 @@ public class XtreemFSInputStream extends FSInputStream {
super.close();
fileHandle.close();
}
+
+ private int readFromBuffer(byte[] bytes, int offset, int length) throws IOException {
+ if (EOF || length == 0) {
+ return 0;
+ }
+
+ if (buffer.remaining() >= length) {
+ // Read from buffer.
+ buffer.get(bytes, offset, length);
+ return length;
+ } else {
+ int bytesLeftToRead = length;
+ int newBytesOffset = offset;
+ int bytesReadFromBuffer = 0;
+
+ if (buffer.hasRemaining()) {
+ // Read remaining bytes from buffer.
+ bytesReadFromBuffer = buffer.remaining();
+ buffer.get(bytes, offset, buffer.remaining());
+ bytesLeftToRead -= bytesReadFromBuffer;
+ newBytesOffset += bytesReadFromBuffer;
+ }
+
+ // Fill buffer.
+ byte[] tmp = new byte[buffer.capacity()];
+ int bytesRead = fileHandle.read(userCredentials, tmp, 0, tmp.length, bufferFilePosition);
+
+ if (bytesRead == 0) {
+ EOF = true;
+ return bytesReadFromBuffer;
+ } else {
+ bufferFilePosition += bytesRead;
+
+ // Put file content in buffer.
+ buffer.clear();
+ buffer.put(tmp, 0, bytesRead);
+ buffer.position(0);
+ buffer.limit(bytesRead);
+
+ // Read left bytes from buffer.
+ return bytesReadFromBuffer + readFromBuffer(bytes, newBytesOffset, bytesLeftToRead);
+ }
+ }
+ }
}
diff --git a/contrib/server-repl-plugin/BabuDB_replication_plugin.jar b/contrib/server-repl-plugin/BabuDB_replication_plugin.jar
index 1321f7117f9d98465c2f651931caa0812ed0df38..9c2114e15adf29ea961acaee4846d8b0d2557915 100644
Binary files a/contrib/server-repl-plugin/BabuDB_replication_plugin.jar and b/contrib/server-repl-plugin/BabuDB_replication_plugin.jar differ
diff --git a/contrib/xtreemfs-osd-farm/xtreemfs-osd-farm b/contrib/xtreemfs-osd-farm/xtreemfs-osd-farm
index b3e2c1e83f0da3c30b92f65c0d96c04fda1717fc..82608439b7311c26ac0396176c5c7e15baed2228 100755
--- a/contrib/xtreemfs-osd-farm/xtreemfs-osd-farm
+++ b/contrib/xtreemfs-osd-farm/xtreemfs-osd-farm
@@ -35,7 +35,7 @@ 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.3.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"
+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
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 2a446d6741f186247e2060074d395b56bad57fdb..91b3459e3cf82c7025980633c40c1856b1ebf998 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -30,7 +30,7 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
endif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
# Set paths for required thirdparty libraries.
-set(CLIENT_GOOGLE_PROTOBUF_CPP "${CMAKE_SOURCE_DIR}/thirdparty/protobuf-2.3.0")
+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()
@@ -119,6 +119,9 @@ IF(WIN32)
ENDIF(WIN32)
# Set required thirdparty libraries.
+
+# Boost
+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)
@@ -126,11 +129,15 @@ endif(BOOST_ROOT)
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")
-FIND_PACKAGE(Boost COMPONENTS system thread program_options regex REQUIRED)
-# Since boost 1.50, the thread library requires the chrono library. This dependency has to be filled in manually on Windows.
+# 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")
- find_package(Boost COMPONENTS chrono REQUIRED)
+ 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)
@@ -144,6 +151,8 @@ if (NOT OPENSSL_FOUND)
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)
SET(REQUIRED_STATIC_LIBRARIES ${CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY})
if(BUILD_CLIENT_TESTS)
@@ -175,20 +184,27 @@ include_directories(${CLIENT_GOOGLE_TEST_CPP}/include)
# Check if this is a 64 Bit system
if(UNIX AND NOT WIN32)
- if(CMAKE_SIZEOF_VOID_P MATCHES "8")
- if(APPLE)
- set(LIBFUSE "fuse_ino64")
- endif(APPLE)
- endif(CMAKE_SIZEOF_VOID_P MATCHES "8")
+ if(APPLE)
+ set(LIBFUSE "osxfuse")
+ endif(APPLE)
endif(UNIX AND NOT WIN32)
-SET(REQUIRED_LIBRARIES ${LIBFUSE} ${LIBATTR} ${LIBCRYPTO} ${LIBSSL} ${LIBPTHREAD})
+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}}")
@@ -197,7 +213,7 @@ endforeach(LIB)
# Define building of binaries.
##########################################
-MESSAGE(STATUS "Configuring XtreemFS client (libxtreemfs, FuseAdapter(mount.xtreemfs) and Volume Tools ({mkfs,rmfs,lsfs}.xtreemfs).")
+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)
@@ -230,19 +246,24 @@ file(GLOB_RECURSE SRCS_XTFS_UTIL src/xtfsutil/xtfsutil_server.cpp)
file(GLOB_RECURSE SRCS_JSONCPP src/json/*.cpp)
if (NOT WIN32)
- 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})
- TARGET_LINK_LIBRARIES(mount.xtreemfs xtreemfs ${LIBFUSE})
+ 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})
+ 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)
- set(UNITTESTS_REQUIRED_SOURCES_fuse ${SRCS_FUSE_ADAPTER} ${SRCS_XTFS_UTIL} ${SRCS_JSONCPP})
- set(UNITTESTS_REQUIRED_LIBRARIES_fuse ${LIBFUSE})
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})
diff --git a/cpp/generated/include/Common.pb.cc b/cpp/generated/include/Common.pb.cc
index e65bf7af01f07c0083ab783b1baf8a067607fede..f2b1cec0229908f8fb86fab4c3afec1b83bfbde7 100644
--- a/cpp/generated/include/Common.pb.cc
+++ b/cpp/generated/include/Common.pb.cc
@@ -1,11 +1,17 @@
// 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)
@@ -112,7 +118,6 @@ struct StaticDescriptorInitializer_include_2fCommon_2eproto {
}
} static_descriptor_initializer_include_2fCommon_2eproto_;
-
// ===================================================================
#ifndef _MSC_VER
@@ -157,7 +162,8 @@ const ::google::protobuf::Descriptor* emptyRequest::descriptor() {
}
const emptyRequest& emptyRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_include_2fCommon_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_include_2fCommon_2eproto();
+ return *default_instance_;
}
emptyRequest* emptyRequest::default_instance_ = NULL;
@@ -206,7 +212,7 @@ void emptyRequest::SerializeWithCachedSizes(
int emptyRequest::ByteSize() const {
int total_size = 0;
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -248,7 +254,7 @@ void emptyRequest::CopyFrom(const emptyRequest& from) {
}
bool emptyRequest::IsInitialized() const {
-
+
return true;
}
@@ -312,7 +318,8 @@ const ::google::protobuf::Descriptor* emptyResponse::descriptor() {
}
const emptyResponse& emptyResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_include_2fCommon_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_include_2fCommon_2eproto();
+ return *default_instance_;
}
emptyResponse* emptyResponse::default_instance_ = NULL;
@@ -361,7 +368,7 @@ void emptyResponse::SerializeWithCachedSizes(
int emptyResponse::ByteSize() const {
int total_size = 0;
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -403,7 +410,7 @@ void emptyResponse::CopyFrom(const emptyResponse& from) {
}
bool emptyResponse::IsInitialized() const {
-
+
return true;
}
diff --git a/cpp/generated/include/Common.pb.h b/cpp/generated/include/Common.pb.h
index c05902c887c7ef3651277becbc3aa915f6617d9f..f7e9eb2581132b5a06962df45c428f8081244917 100644
--- a/cpp/generated/include/Common.pb.h
+++ b/cpp/generated/include/Common.pb.h
@@ -8,21 +8,22 @@
#include
-#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#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 {
@@ -42,29 +43,29 @@ 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);
@@ -72,7 +73,7 @@ class emptyRequest : public ::google::protobuf::Message {
void MergeFrom(const emptyRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -85,35 +86,26 @@ class emptyRequest : public ::google::protobuf::Message {
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();
-
- ::google::protobuf::uint32 _has_bits_[1];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static emptyRequest* default_instance_;
};
@@ -123,29 +115,29 @@ 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);
@@ -153,7 +145,7 @@ class emptyResponse : public ::google::protobuf::Message {
void MergeFrom(const emptyResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -166,35 +158,26 @@ class emptyResponse : public ::google::protobuf::Message {
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();
-
- ::google::protobuf::uint32 _has_bits_[1];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static emptyResponse* default_instance_;
};
diff --git a/cpp/generated/include/PBRPC.pb.cc b/cpp/generated/include/PBRPC.pb.cc
index 6e4f642af327cc8f1793a893ba58fa4064320d8a..c6f074865f05be1c8ca4d865d7d344715e5cba9e 100644
--- a/cpp/generated/include/PBRPC.pb.cc
+++ b/cpp/generated/include/PBRPC.pb.cc
@@ -1,11 +1,17 @@
// 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)
@@ -84,7 +90,6 @@ struct 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);
diff --git a/cpp/generated/include/PBRPC.pb.h b/cpp/generated/include/PBRPC.pb.h
index 880206c5081c7652d28d931b9522a61aed629671..1151f71c4a58a973995fcc6bd6d9ee9bee653e90 100644
--- a/cpp/generated/include/PBRPC.pb.h
+++ b/cpp/generated/include/PBRPC.pb.h
@@ -8,12 +8,12 @@
#include
-#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#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.
@@ -22,7 +22,6 @@
#include
#include
#include
-#include
#include "google/protobuf/descriptor.pb.h"
// @@protoc_insertion_point(includes)
diff --git a/cpp/generated/pbrpc/Ping.pb.cc b/cpp/generated/pbrpc/Ping.pb.cc
index 9f44e8f7dc1b02516cd2072d2444c4f95b9ac9c7..e90bd96c89af7eafc8cb59816413d3e032c8d2df 100644
--- a/cpp/generated/pbrpc/Ping.pb.cc
+++ b/cpp/generated/pbrpc/Ping.pb.cc
@@ -1,11 +1,17 @@
// 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)
@@ -33,7 +39,6 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
const ::google::protobuf::Descriptor* Ping_emptyResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
Ping_emptyResponse_reflection_ = NULL;
-const ::google::protobuf::ServiceDescriptor* PingService_descriptor_ = NULL;
} // namespace
@@ -134,7 +139,6 @@ void protobuf_AssignDesc_pbrpc_2fPing_2eproto() {
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(Ping_emptyResponse));
- PingService_descriptor_ = file->service(0);
}
namespace {
@@ -225,10 +229,8 @@ struct StaticDescriptorInitializer_pbrpc_2fPing_2eproto {
}
} static_descriptor_initializer_pbrpc_2fPing_2eproto_;
-
// ===================================================================
-const ::std::string PingRequest::_default_text_;
#ifndef _MSC_VER
const int PingRequest::kTextFieldNumber;
const int PingRequest::kSendErrorFieldNumber;
@@ -250,7 +252,7 @@ PingRequest::PingRequest(const PingRequest& from)
void PingRequest::SharedCtor() {
_cached_size_ = 0;
- text_ = const_cast< ::std::string*>(&_default_text_);
+ text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
senderror_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -260,7 +262,7 @@ PingRequest::~PingRequest() {
}
void PingRequest::SharedDtor() {
- if (text_ != &_default_text_) {
+ if (text_ != &::google::protobuf::internal::kEmptyString) {
delete text_;
}
if (this != default_instance_) {
@@ -278,7 +280,8 @@ const ::google::protobuf::Descriptor* PingRequest::descriptor() {
}
const PingRequest& PingRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto();
+ return *default_instance_;
}
PingRequest* PingRequest::default_instance_ = NULL;
@@ -289,8 +292,8 @@ PingRequest* PingRequest::New() const {
void PingRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (text_ != &_default_text_) {
+ if (has_text()) {
+ if (text_ != &::google::protobuf::internal::kEmptyString) {
text_->clear();
}
}
@@ -321,7 +324,7 @@ bool PingRequest::MergePartialFromCodedStream(
if (input->ExpectTag(16)) goto parse_sendError;
break;
}
-
+
// required bool sendError = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -330,14 +333,14 @@ bool PingRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &senderror_)));
- _set_bit(1);
+ set_has_senderror();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -357,19 +360,19 @@ bool PingRequest::MergePartialFromCodedStream(
void PingRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string text = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_senderror()) {
::google::protobuf::internal::WireFormatLite::WriteBool(2, this->senderror(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -379,7 +382,7 @@ void PingRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* PingRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string text = 1;
- if (_has_bit(0)) {
+ if (has_text()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->text().data(), this->text().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -387,12 +390,12 @@ void PingRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->text(), target);
}
-
+
// required bool sendError = 2;
- if (_has_bit(1)) {
+ 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);
@@ -402,7 +405,7 @@ void PingRequest::SerializeWithCachedSizes(
int PingRequest::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string text = 1;
if (has_text()) {
@@ -410,12 +413,12 @@ int PingRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->text());
}
-
+
// required bool sendError = 2;
if (has_senderror()) {
total_size += 1 + 1;
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -443,10 +446,10 @@ void PingRequest::MergeFrom(const ::google::protobuf::Message& from) {
void PingRequest::MergeFrom(const PingRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_text()) {
set_text(from.text());
}
- if (from._has_bit(1)) {
+ if (from.has_senderror()) {
set_senderror(from.senderror());
}
}
@@ -467,7 +470,7 @@ void PingRequest::CopyFrom(const PingRequest& from) {
bool PingRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
@@ -492,7 +495,6 @@ void PingRequest::Swap(PingRequest* other) {
// ===================================================================
-const ::std::string PingResponse_PingResult::_default_text_;
#ifndef _MSC_VER
const int PingResponse_PingResult::kTextFieldNumber;
#endif // !_MSC_VER
@@ -513,7 +515,7 @@ PingResponse_PingResult::PingResponse_PingResult(const PingResponse_PingResult&
void PingResponse_PingResult::SharedCtor() {
_cached_size_ = 0;
- text_ = const_cast< ::std::string*>(&_default_text_);
+ text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -522,7 +524,7 @@ PingResponse_PingResult::~PingResponse_PingResult() {
}
void PingResponse_PingResult::SharedDtor() {
- if (text_ != &_default_text_) {
+ if (text_ != &::google::protobuf::internal::kEmptyString) {
delete text_;
}
if (this != default_instance_) {
@@ -540,7 +542,8 @@ const ::google::protobuf::Descriptor* PingResponse_PingResult::descriptor() {
}
const PingResponse_PingResult& PingResponse_PingResult::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto();
+ return *default_instance_;
}
PingResponse_PingResult* PingResponse_PingResult::default_instance_ = NULL;
@@ -551,8 +554,8 @@ PingResponse_PingResult* PingResponse_PingResult::New() const {
void PingResponse_PingResult::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (text_ != &_default_text_) {
+ if (has_text()) {
+ if (text_ != &::google::protobuf::internal::kEmptyString) {
text_->clear();
}
}
@@ -582,7 +585,7 @@ bool PingResponse_PingResult::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -602,14 +605,14 @@ bool PingResponse_PingResult::MergePartialFromCodedStream(
void PingResponse_PingResult::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string text = 1;
- if (_has_bit(0)) {
+ 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);
@@ -619,7 +622,7 @@ void PingResponse_PingResult::SerializeWithCachedSizes(
::google::protobuf::uint8* PingResponse_PingResult::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string text = 1;
- if (_has_bit(0)) {
+ if (has_text()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->text().data(), this->text().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -627,7 +630,7 @@ void PingResponse_PingResult::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->text(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -637,7 +640,7 @@ void PingResponse_PingResult::SerializeWithCachedSizes(
int PingResponse_PingResult::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string text = 1;
if (has_text()) {
@@ -645,7 +648,7 @@ int PingResponse_PingResult::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->text());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -673,7 +676,7 @@ void PingResponse_PingResult::MergeFrom(const ::google::protobuf::Message& from)
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_bit(0)) {
+ if (from.has_text()) {
set_text(from.text());
}
}
@@ -694,7 +697,7 @@ void PingResponse_PingResult::CopyFrom(const PingResponse_PingResult& from) {
bool PingResponse_PingResult::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -718,7 +721,6 @@ void PingResponse_PingResult::Swap(PingResponse_PingResult* other) {
// -------------------------------------------------------------------
-const ::std::string PingResponse_PingError::_default_errormessage_;
#ifndef _MSC_VER
const int PingResponse_PingError::kErrorMessageFieldNumber;
#endif // !_MSC_VER
@@ -739,7 +741,7 @@ PingResponse_PingError::PingResponse_PingError(const PingResponse_PingError& fro
void PingResponse_PingError::SharedCtor() {
_cached_size_ = 0;
- errormessage_ = const_cast< ::std::string*>(&_default_errormessage_);
+ errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -748,7 +750,7 @@ PingResponse_PingError::~PingResponse_PingError() {
}
void PingResponse_PingError::SharedDtor() {
- if (errormessage_ != &_default_errormessage_) {
+ if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
delete errormessage_;
}
if (this != default_instance_) {
@@ -766,7 +768,8 @@ const ::google::protobuf::Descriptor* PingResponse_PingError::descriptor() {
}
const PingResponse_PingError& PingResponse_PingError::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto();
+ return *default_instance_;
}
PingResponse_PingError* PingResponse_PingError::default_instance_ = NULL;
@@ -777,8 +780,8 @@ PingResponse_PingError* PingResponse_PingError::New() const {
void PingResponse_PingError::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (errormessage_ != &_default_errormessage_) {
+ if (has_errormessage()) {
+ if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
errormessage_->clear();
}
}
@@ -808,7 +811,7 @@ bool PingResponse_PingError::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -828,14 +831,14 @@ bool PingResponse_PingError::MergePartialFromCodedStream(
void PingResponse_PingError::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string errorMessage = 1;
- if (_has_bit(0)) {
+ 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);
@@ -845,7 +848,7 @@ void PingResponse_PingError::SerializeWithCachedSizes(
::google::protobuf::uint8* PingResponse_PingError::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string errorMessage = 1;
- if (_has_bit(0)) {
+ if (has_errormessage()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->errormessage().data(), this->errormessage().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -853,7 +856,7 @@ void PingResponse_PingError::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->errormessage(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -863,7 +866,7 @@ void PingResponse_PingError::SerializeWithCachedSizes(
int PingResponse_PingError::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string errorMessage = 1;
if (has_errormessage()) {
@@ -871,7 +874,7 @@ int PingResponse_PingError::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->errormessage());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -899,7 +902,7 @@ void PingResponse_PingError::MergeFrom(const ::google::protobuf::Message& from)
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_bit(0)) {
+ if (from.has_errormessage()) {
set_errormessage(from.errormessage());
}
}
@@ -920,7 +923,7 @@ void PingResponse_PingError::CopyFrom(const PingResponse_PingError& from) {
bool PingResponse_PingError::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -994,7 +997,8 @@ const ::google::protobuf::Descriptor* PingResponse::descriptor() {
}
const PingResponse& PingResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto();
+ return *default_instance_;
}
PingResponse* PingResponse::default_instance_ = NULL;
@@ -1005,10 +1009,10 @@ PingResponse* PingResponse::New() const {
void PingResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_result()) {
if (result_ != NULL) result_->::xtreemfs::pbrpc::PingResponse_PingResult::Clear();
}
- if (_has_bit(1)) {
+ if (has_error()) {
if (error_ != NULL) error_->::xtreemfs::pbrpc::PingResponse_PingError::Clear();
}
}
@@ -1034,7 +1038,7 @@ bool PingResponse::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_error;
break;
}
-
+
// optional .xtreemfs.pbrpc.PingResponse.PingError error = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1048,7 +1052,7 @@ bool PingResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1068,17 +1072,17 @@ bool PingResponse::MergePartialFromCodedStream(
void PingResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
- if (_has_bit(0)) {
+ if (has_result()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->result(), output);
}
-
+
// optional .xtreemfs.pbrpc.PingResponse.PingError error = 2;
- if (_has_bit(1)) {
+ if (has_error()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->error(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -1088,19 +1092,19 @@ void PingResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* PingResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
- if (_has_bit(0)) {
+ if (has_result()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->result(), target);
}
-
+
// optional .xtreemfs.pbrpc.PingResponse.PingError error = 2;
- if (_has_bit(1)) {
+ 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);
@@ -1110,7 +1114,7 @@ void PingResponse::SerializeWithCachedSizes(
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()) {
@@ -1118,14 +1122,14 @@ int PingResponse::ByteSize() const {
::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 +=
@@ -1153,10 +1157,10 @@ void PingResponse::MergeFrom(const ::google::protobuf::Message& from) {
void PingResponse::MergeFrom(const PingResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_result()) {
mutable_result()->::xtreemfs::pbrpc::PingResponse_PingResult::MergeFrom(from.result());
}
- if (from._has_bit(1)) {
+ if (from.has_error()) {
mutable_error()->::xtreemfs::pbrpc::PingResponse_PingError::MergeFrom(from.error());
}
}
@@ -1176,7 +1180,7 @@ void PingResponse::CopyFrom(const PingResponse& from) {
}
bool PingResponse::IsInitialized() const {
-
+
if (has_result()) {
if (!this->result().IsInitialized()) return false;
}
@@ -1249,7 +1253,8 @@ const ::google::protobuf::Descriptor* Ping_emptyRequest::descriptor() {
}
const Ping_emptyRequest& Ping_emptyRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto();
+ return *default_instance_;
}
Ping_emptyRequest* Ping_emptyRequest::default_instance_ = NULL;
@@ -1298,7 +1303,7 @@ void Ping_emptyRequest::SerializeWithCachedSizes(
int Ping_emptyRequest::ByteSize() const {
int total_size = 0;
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -1340,7 +1345,7 @@ void Ping_emptyRequest::CopyFrom(const Ping_emptyRequest& from) {
}
bool Ping_emptyRequest::IsInitialized() const {
-
+
return true;
}
@@ -1404,7 +1409,8 @@ const ::google::protobuf::Descriptor* Ping_emptyResponse::descriptor() {
}
const Ping_emptyResponse& Ping_emptyResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto();
+ return *default_instance_;
}
Ping_emptyResponse* Ping_emptyResponse::default_instance_ = NULL;
@@ -1453,7 +1459,7 @@ void Ping_emptyResponse::SerializeWithCachedSizes(
int Ping_emptyResponse::ByteSize() const {
int total_size = 0;
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -1495,7 +1501,7 @@ void Ping_emptyResponse::CopyFrom(const Ping_emptyResponse& from) {
}
bool Ping_emptyResponse::IsInitialized() const {
-
+
return true;
}
@@ -1515,115 +1521,6 @@ void Ping_emptyResponse::Swap(Ping_emptyResponse* other) {
}
-// ===================================================================
-
-PingService::~PingService() {}
-
-const ::google::protobuf::ServiceDescriptor* PingService::descriptor() {
- protobuf_AssignDescriptorsOnce();
- return PingService_descriptor_;
-}
-
-const ::google::protobuf::ServiceDescriptor* PingService::GetDescriptor() {
- protobuf_AssignDescriptorsOnce();
- return PingService_descriptor_;
-}
-
-void PingService::doPing(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::PingRequest*,
- ::xtreemfs::pbrpc::PingResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method doPing() not implemented.");
- done->Run();
-}
-
-void PingService::emptyPing(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Ping_emptyRequest*,
- ::xtreemfs::pbrpc::Ping_emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method emptyPing() not implemented.");
- done->Run();
-}
-
-void PingService::CallMethod(const ::google::protobuf::MethodDescriptor* method,
- ::google::protobuf::RpcController* controller,
- const ::google::protobuf::Message* request,
- ::google::protobuf::Message* response,
- ::google::protobuf::Closure* done) {
- GOOGLE_DCHECK_EQ(method->service(), PingService_descriptor_);
- switch(method->index()) {
- case 0:
- doPing(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::PingResponse*>(response),
- done);
- break;
- case 1:
- emptyPing(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::Ping_emptyResponse*>(response),
- done);
- break;
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- break;
- }
-}
-
-const ::google::protobuf::Message& PingService::GetRequestPrototype(
- const ::google::protobuf::MethodDescriptor* method) const {
- GOOGLE_DCHECK_EQ(method->service(), descriptor());
- switch(method->index()) {
- case 0:
- return ::xtreemfs::pbrpc::PingRequest::default_instance();
- case 1:
- return ::xtreemfs::pbrpc::Ping_emptyRequest::default_instance();
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- return *reinterpret_cast< ::google::protobuf::Message*>(NULL);
- }
-}
-
-const ::google::protobuf::Message& PingService::GetResponsePrototype(
- const ::google::protobuf::MethodDescriptor* method) const {
- GOOGLE_DCHECK_EQ(method->service(), descriptor());
- switch(method->index()) {
- case 0:
- return ::xtreemfs::pbrpc::PingResponse::default_instance();
- case 1:
- return ::xtreemfs::pbrpc::Ping_emptyResponse::default_instance();
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- return *reinterpret_cast< ::google::protobuf::Message*>(NULL);
- }
-}
-
-PingService_Stub::PingService_Stub(::google::protobuf::RpcChannel* channel)
- : channel_(channel), owns_channel_(false) {}
-PingService_Stub::PingService_Stub(
- ::google::protobuf::RpcChannel* channel,
- ::google::protobuf::Service::ChannelOwnership ownership)
- : channel_(channel),
- owns_channel_(ownership == ::google::protobuf::Service::STUB_OWNS_CHANNEL) {}
-PingService_Stub::~PingService_Stub() {
- if (owns_channel_) delete channel_;
-}
-
-void PingService_Stub::doPing(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::PingRequest* request,
- ::xtreemfs::pbrpc::PingResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(0),
- controller, request, response, done);
-}
-void PingService_Stub::emptyPing(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Ping_emptyRequest* request,
- ::xtreemfs::pbrpc::Ping_emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(1),
- controller, request, response, done);
-}
-
// @@protoc_insertion_point(namespace_scope)
} // namespace pbrpc
diff --git a/cpp/generated/pbrpc/Ping.pb.h b/cpp/generated/pbrpc/Ping.pb.h
index a0f02e7da923016892aa6f626fab4872ab1693e2..5e9c266bf2e7c551c8ba1df5d8f1a3f51cf1ef48 100644
--- a/cpp/generated/pbrpc/Ping.pb.h
+++ b/cpp/generated/pbrpc/Ping.pb.h
@@ -8,22 +8,22 @@
#include
-#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#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 "include/PBRPC.pb.h"
// @@protoc_insertion_point(includes)
@@ -48,29 +48,29 @@ 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);
@@ -78,7 +78,7 @@ class PingRequest : public ::google::protobuf::Message {
void MergeFrom(const PingRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -91,13 +91,13 @@ class PingRequest : public ::google::protobuf::Message {
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();
@@ -107,39 +107,35 @@ class PingRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* text_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static PingRequest* default_instance_;
};
@@ -149,29 +145,29 @@ 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);
@@ -179,7 +175,7 @@ class PingResponse_PingResult : public ::google::protobuf::Message {
void MergeFrom(const PingResponse_PingResult& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -192,13 +188,13 @@ class PingResponse_PingResult : public ::google::protobuf::Message {
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();
@@ -208,31 +204,25 @@ class PingResponse_PingResult : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* text_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static PingResponse_PingResult* default_instance_;
};
@@ -242,29 +232,29 @@ 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);
@@ -272,7 +262,7 @@ class PingResponse_PingError : public ::google::protobuf::Message {
void MergeFrom(const PingResponse_PingError& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -285,13 +275,13 @@ class PingResponse_PingError : public ::google::protobuf::Message {
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();
@@ -301,31 +291,25 @@ class PingResponse_PingError : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* errormessage_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static PingResponse_PingError* default_instance_;
};
@@ -335,29 +319,29 @@ 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);
@@ -365,7 +349,7 @@ class PingResponse : public ::google::protobuf::Message {
void MergeFrom(const PingResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -378,54 +362,53 @@ class PingResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static PingResponse* default_instance_;
};
@@ -435,29 +418,29 @@ 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);
@@ -465,7 +448,7 @@ class Ping_emptyRequest : public ::google::protobuf::Message {
void MergeFrom(const Ping_emptyRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -478,35 +461,26 @@ class Ping_emptyRequest : public ::google::protobuf::Message {
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();
-
- ::google::protobuf::uint32 _has_bits_[1];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Ping_emptyRequest* default_instance_;
};
@@ -516,29 +490,29 @@ 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);
@@ -546,7 +520,7 @@ class Ping_emptyResponse : public ::google::protobuf::Message {
void MergeFrom(const Ping_emptyResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -559,107 +533,31 @@ class Ping_emptyResponse : public ::google::protobuf::Message {
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();
-
- ::google::protobuf::uint32 _has_bits_[1];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Ping_emptyResponse* default_instance_;
};
// ===================================================================
-class PingService_Stub;
-
-class PingService : public ::google::protobuf::Service {
- protected:
- // This class should be treated as an abstract interface.
- inline PingService() {};
- public:
- virtual ~PingService();
-
- typedef PingService_Stub Stub;
-
- static const ::google::protobuf::ServiceDescriptor* descriptor();
-
- virtual void doPing(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::PingRequest* request,
- ::xtreemfs::pbrpc::PingResponse* response,
- ::google::protobuf::Closure* done);
- virtual void emptyPing(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Ping_emptyRequest* request,
- ::xtreemfs::pbrpc::Ping_emptyResponse* response,
- ::google::protobuf::Closure* done);
-
- // implements Service ----------------------------------------------
-
- const ::google::protobuf::ServiceDescriptor* GetDescriptor();
- void CallMethod(const ::google::protobuf::MethodDescriptor* method,
- ::google::protobuf::RpcController* controller,
- const ::google::protobuf::Message* request,
- ::google::protobuf::Message* response,
- ::google::protobuf::Closure* done);
- const ::google::protobuf::Message& GetRequestPrototype(
- const ::google::protobuf::MethodDescriptor* method) const;
- const ::google::protobuf::Message& GetResponsePrototype(
- const ::google::protobuf::MethodDescriptor* method) const;
-
- private:
- GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PingService);
-};
-
-class PingService_Stub : public PingService {
- public:
- PingService_Stub(::google::protobuf::RpcChannel* channel);
- PingService_Stub(::google::protobuf::RpcChannel* channel,
- ::google::protobuf::Service::ChannelOwnership ownership);
- ~PingService_Stub();
-
- inline ::google::protobuf::RpcChannel* channel() { return channel_; }
-
- // implements PingService ------------------------------------------
-
- void doPing(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::PingRequest* request,
- ::xtreemfs::pbrpc::PingResponse* response,
- ::google::protobuf::Closure* done);
- void emptyPing(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Ping_emptyRequest* request,
- ::xtreemfs::pbrpc::Ping_emptyResponse* response,
- ::google::protobuf::Closure* done);
- private:
- ::google::protobuf::RpcChannel* channel_;
- bool owns_channel_;
- GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PingService_Stub);
-};
-
-
-// ===================================================================
-
// ===================================================================
@@ -667,59 +565,93 @@ class PingService_Stub : public PingService {
// required string text = 1;
inline bool PingRequest::has_text() const {
- return _has_bit(0);
+ 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_ != &_default_text_) {
+ if (text_ != &::google::protobuf::internal::kEmptyString) {
text_->clear();
}
- _clear_bit(0);
+ clear_has_text();
}
inline const ::std::string& PingRequest::text() const {
return *text_;
}
inline void PingRequest::set_text(const ::std::string& value) {
- _set_bit(0);
- if (text_ == &_default_text_) {
+ 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_bit(0);
- if (text_ == &_default_text_) {
+ 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_bit(0);
- if (text_ == &_default_text_) {
+ 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_bit(0);
- if (text_ == &_default_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_bit(1);
+ 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_bit(1);
+ clear_has_senderror();
}
inline bool PingRequest::senderror() const {
return senderror_;
}
inline void PingRequest::set_senderror(bool value) {
- _set_bit(1);
+ set_has_senderror();
senderror_ = value;
}
@@ -729,45 +661,73 @@ inline void PingRequest::set_senderror(bool value) {
// required string text = 1;
inline bool PingResponse_PingResult::has_text() const {
- return _has_bit(0);
+ 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_ != &_default_text_) {
+ if (text_ != &::google::protobuf::internal::kEmptyString) {
text_->clear();
}
- _clear_bit(0);
+ clear_has_text();
}
inline const ::std::string& PingResponse_PingResult::text() const {
return *text_;
}
inline void PingResponse_PingResult::set_text(const ::std::string& value) {
- _set_bit(0);
- if (text_ == &_default_text_) {
+ 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_bit(0);
- if (text_ == &_default_text_) {
+ 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_bit(0);
- if (text_ == &_default_text_) {
+ 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_bit(0);
- if (text_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -775,45 +735,73 @@ inline ::std::string* PingResponse_PingResult::mutable_text() {
// required string errorMessage = 1;
inline bool PingResponse_PingError::has_errormessage() const {
- return _has_bit(0);
+ 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_ != &_default_errormessage_) {
+ if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
errormessage_->clear();
}
- _clear_bit(0);
+ clear_has_errormessage();
}
inline const ::std::string& PingResponse_PingError::errormessage() const {
return *errormessage_;
}
inline void PingResponse_PingError::set_errormessage(const ::std::string& value) {
- _set_bit(0);
- if (errormessage_ == &_default_errormessage_) {
+ 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_bit(0);
- if (errormessage_ == &_default_errormessage_) {
+ 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_bit(0);
- if (errormessage_ == &_default_errormessage_) {
+ 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_bit(0);
- if (errormessage_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -821,37 +809,79 @@ inline ::std::string* PingResponse_PingError::mutable_errormessage() {
// optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
inline bool PingResponse::has_result() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ 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_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ 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();
+ }
+}
// -------------------------------------------------------------------
diff --git a/cpp/generated/pbrpc/PingServiceClient.h b/cpp/generated/pbrpc/PingServiceClient.h
index a428d997d841ca72cba8ecccf2e373372a4167ab..82a546ffc9fc1a2cfd3ef6eb2cbb10367c6ad55f 100644
--- a/cpp/generated/pbrpc/PingServiceClient.h
+++ b/cpp/generated/pbrpc/PingServiceClient.h
@@ -1,4 +1,4 @@
-//automatically generated from Ping.proto at Thu Mar 21 17:09:47 CET 2013
+//automatically generated from Ping.proto at Mon Nov 11 11:47:00 CET 2013
//(c) 2013. See LICENSE file for details.
#ifndef PINGSERVICECLIENT_H
diff --git a/cpp/generated/pbrpc/PingServiceConstants.h b/cpp/generated/pbrpc/PingServiceConstants.h
index d01d47d7b25c6583bb411790bc3ae35b9d0b6dc4..e659f0cd41d6a5b212df3c9e29c334d920951054 100644
--- a/cpp/generated/pbrpc/PingServiceConstants.h
+++ b/cpp/generated/pbrpc/PingServiceConstants.h
@@ -1,4 +1,4 @@
-//automatically generated from Ping.proto at Thu Mar 21 17:09:47 CET 2013
+//automatically generated from Ping.proto at Mon Nov 11 11:47:00 CET 2013
//(c) 2013. See LICENSE file for details.
#ifndef PINGSERVICECONSTANTS_H_
diff --git a/cpp/generated/pbrpc/RPC.pb.cc b/cpp/generated/pbrpc/RPC.pb.cc
index bb8168e29e24a554efe9058d903b805211f7038d..6787fd799ecf642b13411dcb453646c1894a6e80 100644
--- a/cpp/generated/pbrpc/RPC.pb.cc
+++ b/cpp/generated/pbrpc/RPC.pb.cc
@@ -1,11 +1,17 @@
// 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)
@@ -212,8 +218,8 @@ void protobuf_AddDesc_pbrpc_2fRPC_2eproto() {
"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_"
+ "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"
@@ -266,7 +272,6 @@ struct 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_;
@@ -346,7 +351,6 @@ bool POSIXErrno_IsValid(int value) {
// ===================================================================
-const ::std::string UserCredentials::_default_username_;
#ifndef _MSC_VER
const int UserCredentials::kUsernameFieldNumber;
const int UserCredentials::kGroupsFieldNumber;
@@ -368,7 +372,7 @@ UserCredentials::UserCredentials(const UserCredentials& from)
void UserCredentials::SharedCtor() {
_cached_size_ = 0;
- username_ = const_cast< ::std::string*>(&_default_username_);
+ username_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -377,7 +381,7 @@ UserCredentials::~UserCredentials() {
}
void UserCredentials::SharedDtor() {
- if (username_ != &_default_username_) {
+ if (username_ != &::google::protobuf::internal::kEmptyString) {
delete username_;
}
if (this != default_instance_) {
@@ -395,7 +399,8 @@ const ::google::protobuf::Descriptor* UserCredentials::descriptor() {
}
const UserCredentials& UserCredentials::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+ return *default_instance_;
}
UserCredentials* UserCredentials::default_instance_ = NULL;
@@ -406,8 +411,8 @@ UserCredentials* UserCredentials::New() const {
void UserCredentials::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (username_ != &_default_username_) {
+ if (has_username()) {
+ if (username_ != &::google::protobuf::internal::kEmptyString) {
username_->clear();
}
}
@@ -438,7 +443,7 @@ bool UserCredentials::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_groups;
break;
}
-
+
// repeated string groups = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -447,7 +452,8 @@ bool UserCredentials::MergePartialFromCodedStream(
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->add_groups()));
::google::protobuf::internal::WireFormat::VerifyUTF8String(
- this->groups(0).data(), this->groups(0).length(),
+ this->groups(this->groups_size() - 1).data(),
+ this->groups(this->groups_size() - 1).length(),
::google::protobuf::internal::WireFormat::PARSE);
} else {
goto handle_uninterpreted;
@@ -456,7 +462,7 @@ bool UserCredentials::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -476,14 +482,14 @@ bool UserCredentials::MergePartialFromCodedStream(
void UserCredentials::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string username = 1;
- if (_has_bit(0)) {
+ 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(
@@ -492,7 +498,7 @@ void UserCredentials::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteString(
2, this->groups(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -502,7 +508,7 @@ void UserCredentials::SerializeWithCachedSizes(
::google::protobuf::uint8* UserCredentials::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string username = 1;
- if (_has_bit(0)) {
+ if (has_username()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->username().data(), this->username().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -510,7 +516,7 @@ void UserCredentials::SerializeWithCachedSizes(
::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(
@@ -519,7 +525,7 @@ void UserCredentials::SerializeWithCachedSizes(
target = ::google::protobuf::internal::WireFormatLite::
WriteStringToArray(2, this->groups(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -529,7 +535,7 @@ void UserCredentials::SerializeWithCachedSizes(
int UserCredentials::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string username = 1;
if (has_username()) {
@@ -537,7 +543,7 @@ int UserCredentials::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->username());
}
-
+
}
// repeated string groups = 2;
total_size += 1 * this->groups_size();
@@ -545,7 +551,7 @@ int UserCredentials::ByteSize() const {
total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
this->groups(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -573,7 +579,7 @@ 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_bit(0)) {
+ if (from.has_username()) {
set_username(from.username());
}
}
@@ -594,7 +600,7 @@ void UserCredentials::CopyFrom(const UserCredentials& from) {
bool UserCredentials::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -619,7 +625,6 @@ void UserCredentials::Swap(UserCredentials* other) {
// ===================================================================
-const ::std::string AuthPassword::_default_password_;
#ifndef _MSC_VER
const int AuthPassword::kPasswordFieldNumber;
#endif // !_MSC_VER
@@ -640,7 +645,7 @@ AuthPassword::AuthPassword(const AuthPassword& from)
void AuthPassword::SharedCtor() {
_cached_size_ = 0;
- password_ = const_cast< ::std::string*>(&_default_password_);
+ password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -649,7 +654,7 @@ AuthPassword::~AuthPassword() {
}
void AuthPassword::SharedDtor() {
- if (password_ != &_default_password_) {
+ if (password_ != &::google::protobuf::internal::kEmptyString) {
delete password_;
}
if (this != default_instance_) {
@@ -667,7 +672,8 @@ const ::google::protobuf::Descriptor* AuthPassword::descriptor() {
}
const AuthPassword& AuthPassword::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+ return *default_instance_;
}
AuthPassword* AuthPassword::default_instance_ = NULL;
@@ -678,8 +684,8 @@ AuthPassword* AuthPassword::New() const {
void AuthPassword::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (password_ != &_default_password_) {
+ if (has_password()) {
+ if (password_ != &::google::protobuf::internal::kEmptyString) {
password_->clear();
}
}
@@ -709,7 +715,7 @@ bool AuthPassword::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -729,14 +735,14 @@ bool AuthPassword::MergePartialFromCodedStream(
void AuthPassword::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string password = 1;
- if (_has_bit(0)) {
+ 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);
@@ -746,7 +752,7 @@ void AuthPassword::SerializeWithCachedSizes(
::google::protobuf::uint8* AuthPassword::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string password = 1;
- if (_has_bit(0)) {
+ if (has_password()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->password().data(), this->password().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -754,7 +760,7 @@ void AuthPassword::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->password(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -764,7 +770,7 @@ void AuthPassword::SerializeWithCachedSizes(
int AuthPassword::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string password = 1;
if (has_password()) {
@@ -772,7 +778,7 @@ int AuthPassword::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->password());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -800,7 +806,7 @@ void AuthPassword::MergeFrom(const ::google::protobuf::Message& from) {
void AuthPassword::MergeFrom(const AuthPassword& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_password()) {
set_password(from.password());
}
}
@@ -821,7 +827,7 @@ void AuthPassword::CopyFrom(const AuthPassword& from) {
bool AuthPassword::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -845,7 +851,6 @@ void AuthPassword::Swap(AuthPassword* other) {
// ===================================================================
-const ::std::string Auth::_default_auth_data_;
#ifndef _MSC_VER
const int Auth::kAuthTypeFieldNumber;
const int Auth::kAuthPasswdFieldNumber;
@@ -871,7 +876,7 @@ void Auth::SharedCtor() {
_cached_size_ = 0;
auth_type_ = 0;
auth_passwd_ = NULL;
- auth_data_ = const_cast< ::std::string*>(&_default_auth_data_);
+ auth_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -880,7 +885,7 @@ Auth::~Auth() {
}
void Auth::SharedDtor() {
- if (auth_data_ != &_default_auth_data_) {
+ if (auth_data_ != &::google::protobuf::internal::kEmptyString) {
delete auth_data_;
}
if (this != default_instance_) {
@@ -899,7 +904,8 @@ const ::google::protobuf::Descriptor* Auth::descriptor() {
}
const Auth& Auth::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+ return *default_instance_;
}
Auth* Auth::default_instance_ = NULL;
@@ -911,11 +917,11 @@ Auth* Auth::New() const {
void Auth::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
auth_type_ = 0;
- if (_has_bit(1)) {
+ if (has_auth_passwd()) {
if (auth_passwd_ != NULL) auth_passwd_->::xtreemfs::pbrpc::AuthPassword::Clear();
}
- if (_has_bit(2)) {
- if (auth_data_ != &_default_auth_data_) {
+ if (has_auth_data()) {
+ if (auth_data_ != &::google::protobuf::internal::kEmptyString) {
auth_data_->clear();
}
}
@@ -938,8 +944,8 @@ bool Auth::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::AuthType_IsValid(value)) {
+ set_auth_type(static_cast< ::xtreemfs::pbrpc::AuthType >(value));
} else {
mutable_unknown_fields()->AddVarint(1, value);
}
@@ -949,7 +955,7 @@ bool Auth::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_auth_data;
break;
}
-
+
// optional bytes auth_data = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -963,7 +969,7 @@ bool Auth::MergePartialFromCodedStream(
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) ==
@@ -977,7 +983,7 @@ bool Auth::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -997,23 +1003,23 @@ bool Auth::MergePartialFromCodedStream(
void Auth::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.AuthType auth_type = 1;
- if (_has_bit(0)) {
+ if (has_auth_type()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
1, this->auth_type(), output);
}
-
+
// optional bytes auth_data = 2;
- if (_has_bit(2)) {
+ if (has_auth_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytes(
2, this->auth_data(), output);
}
-
+
// optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
- if (_has_bit(1)) {
+ 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);
@@ -1023,25 +1029,25 @@ void Auth::SerializeWithCachedSizes(
::google::protobuf::uint8* Auth::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.AuthType auth_type = 1;
- if (_has_bit(0)) {
+ if (has_auth_type()) {
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1, this->auth_type(), target);
}
-
+
// optional bytes auth_data = 2;
- if (_has_bit(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_bit(1)) {
+ 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);
@@ -1051,28 +1057,28 @@ void Auth::SerializeWithCachedSizes(
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 +=
@@ -1100,13 +1106,13 @@ void Auth::MergeFrom(const ::google::protobuf::Message& from) {
void Auth::MergeFrom(const Auth& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_auth_type()) {
set_auth_type(from.auth_type());
}
- if (from._has_bit(1)) {
+ if (from.has_auth_passwd()) {
mutable_auth_passwd()->::xtreemfs::pbrpc::AuthPassword::MergeFrom(from.auth_passwd());
}
- if (from._has_bit(2)) {
+ if (from.has_auth_data()) {
set_auth_data(from.auth_data());
}
}
@@ -1127,7 +1133,7 @@ void Auth::CopyFrom(const Auth& from) {
bool Auth::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
if (has_auth_passwd()) {
if (!this->auth_passwd().IsInitialized()) return false;
}
@@ -1210,7 +1216,8 @@ const ::google::protobuf::Descriptor* RPCHeader_RequestHeader::descriptor() {
}
const RPCHeader_RequestHeader& RPCHeader_RequestHeader::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+ return *default_instance_;
}
RPCHeader_RequestHeader* RPCHeader_RequestHeader::default_instance_ = NULL;
@@ -1223,10 +1230,10 @@ void RPCHeader_RequestHeader::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
interface_id_ = 0u;
proc_id_ = 0u;
- if (_has_bit(2)) {
+ if (has_user_creds()) {
if (user_creds_ != NULL) user_creds_->::xtreemfs::pbrpc::UserCredentials::Clear();
}
- if (_has_bit(3)) {
+ if (has_auth_data()) {
if (auth_data_ != NULL) auth_data_->::xtreemfs::pbrpc::Auth::Clear();
}
}
@@ -1247,14 +1254,14 @@ bool RPCHeader_RequestHeader::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &interface_id_)));
- _set_bit(0);
+ 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) ==
@@ -1263,14 +1270,14 @@ bool RPCHeader_RequestHeader::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &proc_id_)));
- _set_bit(1);
+ 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) ==
@@ -1284,7 +1291,7 @@ bool RPCHeader_RequestHeader::MergePartialFromCodedStream(
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) ==
@@ -1298,7 +1305,7 @@ bool RPCHeader_RequestHeader::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1318,27 +1325,27 @@ bool RPCHeader_RequestHeader::MergePartialFromCodedStream(
void RPCHeader_RequestHeader::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed32 interface_id = 1;
- if (_has_bit(0)) {
+ if (has_interface_id()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->interface_id(), output);
}
-
+
// required fixed32 proc_id = 2;
- if (_has_bit(1)) {
+ if (has_proc_id()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->proc_id(), output);
}
-
+
// required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
- if (_has_bit(2)) {
+ if (has_user_creds()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3, this->user_creds(), output);
}
-
+
// required .xtreemfs.pbrpc.Auth auth_data = 4;
- if (_has_bit(3)) {
+ 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);
@@ -1348,29 +1355,29 @@ void RPCHeader_RequestHeader::SerializeWithCachedSizes(
::google::protobuf::uint8* RPCHeader_RequestHeader::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed32 interface_id = 1;
- if (_has_bit(0)) {
+ if (has_interface_id()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->interface_id(), target);
}
-
+
// required fixed32 proc_id = 2;
- if (_has_bit(1)) {
+ if (has_proc_id()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->proc_id(), target);
}
-
+
// required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
- if (_has_bit(2)) {
+ if (has_user_creds()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
3, this->user_creds(), target);
}
-
+
// required .xtreemfs.pbrpc.Auth auth_data = 4;
- if (_has_bit(3)) {
+ 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);
@@ -1380,32 +1387,32 @@ void RPCHeader_RequestHeader::SerializeWithCachedSizes(
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 +=
@@ -1433,16 +1440,16 @@ void RPCHeader_RequestHeader::MergeFrom(const ::google::protobuf::Message& from)
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_bit(0)) {
+ if (from.has_interface_id()) {
set_interface_id(from.interface_id());
}
- if (from._has_bit(1)) {
+ if (from.has_proc_id()) {
set_proc_id(from.proc_id());
}
- if (from._has_bit(2)) {
+ if (from.has_user_creds()) {
mutable_user_creds()->::xtreemfs::pbrpc::UserCredentials::MergeFrom(from.user_creds());
}
- if (from._has_bit(3)) {
+ if (from.has_auth_data()) {
mutable_auth_data()->::xtreemfs::pbrpc::Auth::MergeFrom(from.auth_data());
}
}
@@ -1463,7 +1470,7 @@ void RPCHeader_RequestHeader::CopyFrom(const RPCHeader_RequestHeader& 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;
}
@@ -1496,9 +1503,6 @@ void RPCHeader_RequestHeader::Swap(RPCHeader_RequestHeader* other) {
// -------------------------------------------------------------------
-const ::std::string RPCHeader_ErrorResponse::_default_error_message_;
-const ::std::string RPCHeader_ErrorResponse::_default_debug_info_;
-const ::std::string RPCHeader_ErrorResponse::_default_redirect_to_server_uuid_;
#ifndef _MSC_VER
const int RPCHeader_ErrorResponse::kErrorTypeFieldNumber;
const int RPCHeader_ErrorResponse::kPosixErrnoFieldNumber;
@@ -1525,9 +1529,9 @@ void RPCHeader_ErrorResponse::SharedCtor() {
_cached_size_ = 0;
error_type_ = 1;
posix_errno_ = 9999;
- error_message_ = const_cast< ::std::string*>(&_default_error_message_);
- debug_info_ = const_cast< ::std::string*>(&_default_debug_info_);
- redirect_to_server_uuid_ = const_cast< ::std::string*>(&_default_redirect_to_server_uuid_);
+ 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_));
}
@@ -1536,13 +1540,13 @@ RPCHeader_ErrorResponse::~RPCHeader_ErrorResponse() {
}
void RPCHeader_ErrorResponse::SharedDtor() {
- if (error_message_ != &_default_error_message_) {
+ if (error_message_ != &::google::protobuf::internal::kEmptyString) {
delete error_message_;
}
- if (debug_info_ != &_default_debug_info_) {
+ if (debug_info_ != &::google::protobuf::internal::kEmptyString) {
delete debug_info_;
}
- if (redirect_to_server_uuid_ != &_default_redirect_to_server_uuid_) {
+ if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) {
delete redirect_to_server_uuid_;
}
if (this != default_instance_) {
@@ -1560,7 +1564,8 @@ const ::google::protobuf::Descriptor* RPCHeader_ErrorResponse::descriptor() {
}
const RPCHeader_ErrorResponse& RPCHeader_ErrorResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+ return *default_instance_;
}
RPCHeader_ErrorResponse* RPCHeader_ErrorResponse::default_instance_ = NULL;
@@ -1573,18 +1578,18 @@ void RPCHeader_ErrorResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
error_type_ = 1;
posix_errno_ = 9999;
- if (_has_bit(2)) {
- if (error_message_ != &_default_error_message_) {
+ if (has_error_message()) {
+ if (error_message_ != &::google::protobuf::internal::kEmptyString) {
error_message_->clear();
}
}
- if (_has_bit(3)) {
- if (debug_info_ != &_default_debug_info_) {
+ if (has_debug_info()) {
+ if (debug_info_ != &::google::protobuf::internal::kEmptyString) {
debug_info_->clear();
}
}
- if (_has_bit(4)) {
- if (redirect_to_server_uuid_ != &_default_redirect_to_server_uuid_) {
+ if (has_redirect_to_server_uuid()) {
+ if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) {
redirect_to_server_uuid_->clear();
}
}
@@ -1607,8 +1612,8 @@ bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::ErrorType_IsValid(value)) {
+ set_error_type(static_cast< ::xtreemfs::pbrpc::ErrorType >(value));
} else {
mutable_unknown_fields()->AddVarint(1, value);
}
@@ -1618,7 +1623,7 @@ bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
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) ==
@@ -1628,8 +1633,8 @@ bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::POSIXErrno_IsValid(value)) {
+ set_posix_errno(static_cast< ::xtreemfs::pbrpc::POSIXErrno >(value));
} else {
mutable_unknown_fields()->AddVarint(2, value);
}
@@ -1639,7 +1644,7 @@ bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_error_message;
break;
}
-
+
// optional string error_message = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1656,7 +1661,7 @@ bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
if (input->ExpectTag(34)) goto parse_debug_info;
break;
}
-
+
// optional string debug_info = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1673,7 +1678,7 @@ bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
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) ==
@@ -1690,7 +1695,7 @@ bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1710,44 +1715,44 @@ bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.ErrorType error_type = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_posix_errno()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
2, this->posix_errno(), output);
}
-
+
// optional string error_message = 3;
- if (_has_bit(2)) {
+ 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_bit(3)) {
+ 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_bit(4)) {
+ 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);
@@ -1757,19 +1762,19 @@ void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* RPCHeader_ErrorResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.ErrorType error_type = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_posix_errno()) {
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
2, this->posix_errno(), target);
}
-
+
// optional string error_message = 3;
- if (_has_bit(2)) {
+ if (has_error_message()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->error_message().data(), this->error_message().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1777,9 +1782,9 @@ void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->error_message(), target);
}
-
+
// optional string debug_info = 4;
- if (_has_bit(3)) {
+ if (has_debug_info()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->debug_info().data(), this->debug_info().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1787,9 +1792,9 @@ void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->debug_info(), target);
}
-
+
// optional string redirect_to_server_uuid = 5;
- if (_has_bit(4)) {
+ 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);
@@ -1797,7 +1802,7 @@ void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
::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);
@@ -1807,41 +1812,41 @@ void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
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 +=
@@ -1869,19 +1874,19 @@ void RPCHeader_ErrorResponse::MergeFrom(const ::google::protobuf::Message& from)
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_bit(0)) {
+ if (from.has_error_type()) {
set_error_type(from.error_type());
}
- if (from._has_bit(1)) {
+ if (from.has_posix_errno()) {
set_posix_errno(from.posix_errno());
}
- if (from._has_bit(2)) {
+ if (from.has_error_message()) {
set_error_message(from.error_message());
}
- if (from._has_bit(3)) {
+ if (from.has_debug_info()) {
set_debug_info(from.debug_info());
}
- if (from._has_bit(4)) {
+ if (from.has_redirect_to_server_uuid()) {
set_redirect_to_server_uuid(from.redirect_to_server_uuid());
}
}
@@ -1902,7 +1907,7 @@ void RPCHeader_ErrorResponse::CopyFrom(const RPCHeader_ErrorResponse& from) {
bool RPCHeader_ErrorResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -1984,7 +1989,8 @@ const ::google::protobuf::Descriptor* RPCHeader::descriptor() {
}
const RPCHeader& RPCHeader::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+ return *default_instance_;
}
RPCHeader* RPCHeader::default_instance_ = NULL;
@@ -1997,10 +2003,10 @@ void RPCHeader::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
call_id_ = 0u;
message_type_ = 0;
- if (_has_bit(2)) {
+ if (has_request_header()) {
if (request_header_ != NULL) request_header_->::xtreemfs::pbrpc::RPCHeader_RequestHeader::Clear();
}
- if (_has_bit(3)) {
+ if (has_error_response()) {
if (error_response_ != NULL) error_response_->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::Clear();
}
}
@@ -2021,14 +2027,14 @@ bool RPCHeader::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &call_id_)));
- _set_bit(0);
+ 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) ==
@@ -2038,8 +2044,8 @@ bool RPCHeader::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::MessageType_IsValid(value)) {
+ set_message_type(static_cast< ::xtreemfs::pbrpc::MessageType >(value));
} else {
mutable_unknown_fields()->AddVarint(2, value);
}
@@ -2049,7 +2055,7 @@ bool RPCHeader::MergePartialFromCodedStream(
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) ==
@@ -2063,7 +2069,7 @@ bool RPCHeader::MergePartialFromCodedStream(
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) ==
@@ -2077,7 +2083,7 @@ bool RPCHeader::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2097,28 +2103,28 @@ bool RPCHeader::MergePartialFromCodedStream(
void RPCHeader::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed32 call_id = 1;
- if (_has_bit(0)) {
+ if (has_call_id()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->call_id(), output);
}
-
+
// required .xtreemfs.pbrpc.MessageType message_type = 2;
- if (_has_bit(1)) {
+ if (has_message_type()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
2, this->message_type(), output);
}
-
+
// optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
- if (_has_bit(2)) {
+ if (has_request_header()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3, this->request_header(), output);
}
-
+
// optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
- if (_has_bit(3)) {
+ 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);
@@ -2128,30 +2134,30 @@ void RPCHeader::SerializeWithCachedSizes(
::google::protobuf::uint8* RPCHeader::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed32 call_id = 1;
- if (_has_bit(0)) {
+ if (has_call_id()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->call_id(), target);
}
-
+
// required .xtreemfs.pbrpc.MessageType message_type = 2;
- if (_has_bit(1)) {
+ 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_bit(2)) {
+ 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_bit(3)) {
+ 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);
@@ -2161,33 +2167,33 @@ void RPCHeader::SerializeWithCachedSizes(
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 +=
@@ -2215,16 +2221,16 @@ void RPCHeader::MergeFrom(const ::google::protobuf::Message& from) {
void RPCHeader::MergeFrom(const RPCHeader& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_call_id()) {
set_call_id(from.call_id());
}
- if (from._has_bit(1)) {
+ if (from.has_message_type()) {
set_message_type(from.message_type());
}
- if (from._has_bit(2)) {
+ if (from.has_request_header()) {
mutable_request_header()->::xtreemfs::pbrpc::RPCHeader_RequestHeader::MergeFrom(from.request_header());
}
- if (from._has_bit(3)) {
+ if (from.has_error_response()) {
mutable_error_response()->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::MergeFrom(from.error_response());
}
}
@@ -2245,7 +2251,7 @@ void RPCHeader::CopyFrom(const RPCHeader& from) {
bool RPCHeader::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
if (has_request_header()) {
if (!this->request_header().IsInitialized()) return false;
}
diff --git a/cpp/generated/pbrpc/RPC.pb.h b/cpp/generated/pbrpc/RPC.pb.h
index 5d1b0991aeba61c45cd237af5ff789c3a56c8dca..822cd5b44ee20165fef36fc09c7e651b6e3178d6 100644
--- a/cpp/generated/pbrpc/RPC.pb.h
+++ b/cpp/generated/pbrpc/RPC.pb.h
@@ -8,21 +8,23 @@
#include
-#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#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
// @@protoc_insertion_point(includes)
namespace xtreemfs {
@@ -142,29 +144,29 @@ 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);
@@ -172,7 +174,7 @@ class UserCredentials : public ::google::protobuf::Message {
void MergeFrom(const UserCredentials& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -185,13 +187,13 @@ class UserCredentials : public ::google::protobuf::Message {
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();
@@ -201,7 +203,9 @@ class UserCredentials : public ::google::protobuf::Message {
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();
@@ -217,32 +221,24 @@ class UserCredentials : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* username_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static UserCredentials* default_instance_;
};
@@ -252,29 +248,29 @@ 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);
@@ -282,7 +278,7 @@ class AuthPassword : public ::google::protobuf::Message {
void MergeFrom(const AuthPassword& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -295,13 +291,13 @@ class AuthPassword : public ::google::protobuf::Message {
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();
@@ -311,31 +307,25 @@ class AuthPassword : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* password_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static AuthPassword* default_instance_;
};
@@ -345,29 +335,29 @@ 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);
@@ -375,7 +365,7 @@ class Auth : public ::google::protobuf::Message {
void MergeFrom(const Auth& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -388,27 +378,29 @@ class Auth : public ::google::protobuf::Message {
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);
-
+ 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();
@@ -418,33 +410,31 @@ class Auth : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
- int auth_type_;
+
::xtreemfs::pbrpc::AuthPassword* auth_passwd_;
::std::string* auth_data_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Auth* default_instance_;
};
@@ -454,29 +444,29 @@ 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);
@@ -484,7 +474,7 @@ class RPCHeader_RequestHeader : public ::google::protobuf::Message {
void MergeFrom(const RPCHeader_RequestHeader& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -497,67 +487,70 @@ class RPCHeader_RequestHeader : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static RPCHeader_RequestHeader* default_instance_;
};
@@ -567,29 +560,29 @@ 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);
@@ -597,7 +590,7 @@ class RPCHeader_ErrorResponse : public ::google::protobuf::Message {
void MergeFrom(const RPCHeader_ErrorResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -610,27 +603,27 @@ class RPCHeader_ErrorResponse : public ::google::protobuf::Message {
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);
-
+ 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);
-
+ 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();
@@ -640,7 +633,9 @@ class RPCHeader_ErrorResponse : public ::google::protobuf::Message {
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();
@@ -650,7 +645,9 @@ class RPCHeader_ErrorResponse : public ::google::protobuf::Message {
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();
@@ -660,37 +657,37 @@ class RPCHeader_ErrorResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
int error_type_;
int posix_errno_;
::std::string* error_message_;
- static const ::std::string _default_error_message_;
::std::string* debug_info_;
- static const ::std::string _default_debug_info_;
::std::string* redirect_to_server_uuid_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static RPCHeader_ErrorResponse* default_instance_;
};
@@ -700,29 +697,29 @@ 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);
@@ -730,7 +727,7 @@ class RPCHeader : public ::google::protobuf::Message {
void MergeFrom(const RPCHeader& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -743,70 +740,73 @@ class RPCHeader : public ::google::protobuf::Message {
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);
-
+ 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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static RPCHeader* default_instance_;
};
@@ -819,45 +819,73 @@ class RPCHeader : public ::google::protobuf::Message {
// required string username = 1;
inline bool UserCredentials::has_username() const {
- return _has_bit(0);
+ 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_ != &_default_username_) {
+ if (username_ != &::google::protobuf::internal::kEmptyString) {
username_->clear();
}
- _clear_bit(0);
+ clear_has_username();
}
inline const ::std::string& UserCredentials::username() const {
return *username_;
}
inline void UserCredentials::set_username(const ::std::string& value) {
- _set_bit(0);
- if (username_ == &_default_username_) {
+ 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_bit(0);
- if (username_ == &_default_username_) {
+ 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_bit(0);
- if (username_ == &_default_username_) {
+ 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_bit(0);
- if (username_ == &_default_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 {
@@ -909,45 +937,73 @@ UserCredentials::mutable_groups() {
// required string password = 1;
inline bool AuthPassword::has_password() const {
- return _has_bit(0);
+ 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_ != &_default_password_) {
+ if (password_ != &::google::protobuf::internal::kEmptyString) {
password_->clear();
}
- _clear_bit(0);
+ clear_has_password();
}
inline const ::std::string& AuthPassword::password() const {
return *password_;
}
inline void AuthPassword::set_password(const ::std::string& value) {
- _set_bit(0);
- if (password_ == &_default_password_) {
+ 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_bit(0);
- if (password_ == &_default_password_) {
+ 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_bit(0);
- if (password_ == &_default_password_) {
+ 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_bit(0);
- if (password_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -955,79 +1011,134 @@ inline ::std::string* AuthPassword::mutable_password() {
// required .xtreemfs.pbrpc.AuthType auth_type = 1;
inline bool Auth::has_auth_type() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_auth_type();
}
-inline xtreemfs::pbrpc::AuthType Auth::auth_type() const {
- return static_cast< xtreemfs::pbrpc::AuthType >(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) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::AuthType_IsValid(value));
- _set_bit(0);
+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_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ 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_bit(2);
+ 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_ != &_default_auth_data_) {
+ if (auth_data_ != &::google::protobuf::internal::kEmptyString) {
auth_data_->clear();
}
- _clear_bit(2);
+ 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_bit(2);
- if (auth_data_ == &_default_auth_data_) {
+ 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_bit(2);
- if (auth_data_ == &_default_auth_data_) {
+ 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_bit(2);
- if (auth_data_ == &_default_auth_data_) {
+ 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_bit(2);
- if (auth_data_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -1035,69 +1146,123 @@ inline ::std::string* Auth::mutable_auth_data() {
// required fixed32 interface_id = 1;
inline bool RPCHeader_RequestHeader::has_interface_id() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ set_has_interface_id();
interface_id_ = value;
}
// required fixed32 proc_id = 2;
inline bool RPCHeader_RequestHeader::has_proc_id() const {
- return _has_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ set_has_proc_id();
proc_id_ = value;
}
// required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
inline bool RPCHeader_RequestHeader::has_user_creds() const {
- return _has_bit(2);
+ 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_bit(2);
+ 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_bit(2);
+ 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_bit(3);
+ 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_bit(3);
+ 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_bit(3);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -1105,163 +1270,259 @@ inline ::xtreemfs::pbrpc::Auth* RPCHeader_RequestHeader::mutable_auth_data() {
// required .xtreemfs.pbrpc.ErrorType error_type = 1;
inline bool RPCHeader_ErrorResponse::has_error_type() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_error_type();
}
-inline xtreemfs::pbrpc::ErrorType RPCHeader_ErrorResponse::error_type() const {
- return static_cast< xtreemfs::pbrpc::ErrorType >(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) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::ErrorType_IsValid(value));
- _set_bit(0);
+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_bit(1);
+ 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_bit(1);
+ clear_has_posix_errno();
}
-inline xtreemfs::pbrpc::POSIXErrno RPCHeader_ErrorResponse::posix_errno() const {
- return static_cast< xtreemfs::pbrpc::POSIXErrno >(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) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::POSIXErrno_IsValid(value));
- _set_bit(1);
+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_bit(2);
+ 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_ != &_default_error_message_) {
+ if (error_message_ != &::google::protobuf::internal::kEmptyString) {
error_message_->clear();
}
- _clear_bit(2);
+ 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_bit(2);
- if (error_message_ == &_default_error_message_) {
+ 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_bit(2);
- if (error_message_ == &_default_error_message_) {
+ 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_bit(2);
- if (error_message_ == &_default_error_message_) {
+ 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_bit(2);
- if (error_message_ == &_default_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_bit(3);
+ 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_ != &_default_debug_info_) {
+ if (debug_info_ != &::google::protobuf::internal::kEmptyString) {
debug_info_->clear();
}
- _clear_bit(3);
+ 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_bit(3);
- if (debug_info_ == &_default_debug_info_) {
+ 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_bit(3);
- if (debug_info_ == &_default_debug_info_) {
+ 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_bit(3);
- if (debug_info_ == &_default_debug_info_) {
+ 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_bit(3);
- if (debug_info_ == &_default_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_bit(4);
+ 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_ != &_default_redirect_to_server_uuid_) {
+ if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) {
redirect_to_server_uuid_->clear();
}
- _clear_bit(4);
+ 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_bit(4);
- if (redirect_to_server_uuid_ == &_default_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;
}
redirect_to_server_uuid_->assign(value);
}
inline void RPCHeader_ErrorResponse::set_redirect_to_server_uuid(const char* value) {
- _set_bit(4);
- if (redirect_to_server_uuid_ == &_default_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;
}
redirect_to_server_uuid_->assign(value);
}
inline void RPCHeader_ErrorResponse::set_redirect_to_server_uuid(const char* value, size_t size) {
- _set_bit(4);
- if (redirect_to_server_uuid_ == &_default_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;
}
redirect_to_server_uuid_->assign(reinterpret_cast(value), size);
}
inline ::std::string* RPCHeader_ErrorResponse::mutable_redirect_to_server_uuid() {
- _set_bit(4);
- if (redirect_to_server_uuid_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -1269,70 +1530,124 @@ inline ::std::string* RPCHeader_ErrorResponse::mutable_redirect_to_server_uuid()
// required fixed32 call_id = 1;
inline bool RPCHeader::has_call_id() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ set_has_call_id();
call_id_ = value;
}
// required .xtreemfs.pbrpc.MessageType message_type = 2;
inline bool RPCHeader::has_message_type() const {
- return _has_bit(1);
+ 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_bit(1);
+ clear_has_message_type();
}
-inline xtreemfs::pbrpc::MessageType RPCHeader::message_type() const {
- return static_cast< xtreemfs::pbrpc::MessageType >(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) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::MessageType_IsValid(value));
- _set_bit(1);
+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_bit(2);
+ 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_bit(2);
+ 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_bit(2);
+ 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_bit(3);
+ 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_bit(3);
+ 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_bit(3);
+ 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)
@@ -1345,20 +1660,20 @@ namespace google {
namespace protobuf {
template <>
-inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::MessageType>() {
- return xtreemfs::pbrpc::MessageType_descriptor();
+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();
+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();
+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();
+inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::POSIXErrno>() {
+ return ::xtreemfs::pbrpc::POSIXErrno_descriptor();
}
} // namespace google
diff --git a/cpp/generated/xtreemfs/DIR.pb.cc b/cpp/generated/xtreemfs/DIR.pb.cc
index 9de6e3e35a9d341462f149047a3e930ed9955132..0fe7bb24a3d0f1826377475ad7b8f7a56e1007c3 100644
--- a/cpp/generated/xtreemfs/DIR.pb.cc
+++ b/cpp/generated/xtreemfs/DIR.pb.cc
@@ -1,11 +1,17 @@
// 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)
@@ -74,7 +80,6 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
configurationSetResponse_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* ServiceType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor_ = NULL;
-const ::google::protobuf::ServiceDescriptor* DirectoryService_descriptor_ = NULL;
} // namespace
@@ -389,7 +394,6 @@ void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto() {
sizeof(configurationSetResponse));
ServiceType_descriptor_ = file->enum_type(0);
ServiceStatus_descriptor_ = file->enum_type(1);
- DirectoryService_descriptor_ = file->service(0);
}
namespace {
@@ -530,58 +534,59 @@ void protobuf_AddDesc_xtreemfs_2fDIR_2eproto() {
"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*j\n\013ServiceTy"
- "pe\022\026\n\022SERVICE_TYPE_MIXED\020\000\022\024\n\020SERVICE_TY"
- "PE_MRC\020\001\022\024\n\020SERVICE_TYPE_OSD\020\002\022\027\n\023SERVIC"
- "E_TYPE_VOLUME\020\003*g\n\rServiceStatus\022\030\n\024SERV"
- "ICE_STATUS_AVAIL\020\000\022 \n\034SERVICE_STATUS_TO_"
- "BE_REMOVED\020\001\022\032\n\026SERVICE_STATUS_REMOVED\020\002"
- "2\355\r\n\020DirectoryService\022u\n\035xtreemfs_addres"
- "s_mappings_get\022(.xtreemfs.pbrpc.addressM"
- "appingGetRequest\032!.xtreemfs.pbrpc.Addres"
- "sMappingSet\"\007\215\265\030\001\000\000\000\022t\n xtreemfs_address"
- "_mappings_remove\022(.xtreemfs.pbrpc.addres"
- "sMappingGetRequest\032\035.xtreemfs.pbrpc.empt"
- "yResponse\"\007\215\265\030\002\000\000\000\022v\n\035xtreemfs_address_m"
- "appings_set\022!.xtreemfs.pbrpc.AddressMapp"
- "ingSet\032).xtreemfs.pbrpc.addressMappingSe"
- "tResponse\"\007\215\265\030\003\000\000\000\022Z\n\025xtreemfs_discover_"
- "dir\022\034.xtreemfs.pbrpc.emptyRequest\032\032.xtre"
- "emfs.pbrpc.DirService\"\007\215\265\030\004\000\000\000\022k\n\032xtreem"
- "fs_global_time_s_get\022\034.xtreemfs.pbrpc.em"
- "ptyRequest\032&.xtreemfs.pbrpc.globalTimeSG"
- "etResponse\"\007\215\265\030\005\000\000\000\022o\n\033xtreemfs_service_"
- "deregister\022(.xtreemfs.pbrpc.serviceDereg"
- "isterRequest\032\035.xtreemfs.pbrpc.emptyRespo"
- "nse\"\007\215\265\030\006\000\000\000\022l\n\034xtreemfs_service_get_by_"
- "name\022\'.xtreemfs.pbrpc.serviceGetByNameRe"
- "quest\032\032.xtreemfs.pbrpc.ServiceSet\"\007\215\265\030\007\000"
- "\000\000\022l\n\034xtreemfs_service_get_by_type\022\'.xtr"
- "eemfs.pbrpc.serviceGetByTypeRequest\032\032.xt"
- "reemfs.pbrpc.ServiceSet\"\007\215\265\030\010\000\000\000\022l\n\034xtre"
- "emfs_service_get_by_uuid\022\'.xtreemfs.pbrp"
- "c.serviceGetByUUIDRequest\032\032.xtreemfs.pbr"
- "pc.ServiceSet\"\007\215\265\030\t\000\000\000\022k\n\030xtreemfs_servi"
- "ce_offline\022\'.xtreemfs.pbrpc.serviceGetBy"
- "UUIDRequest\032\035.xtreemfs.pbrpc.emptyRespon"
- "se\"\007\215\265\030\n\000\000\000\022u\n\031xtreemfs_service_register"
- "\022&.xtreemfs.pbrpc.serviceRegisterRequest"
- "\032\'.xtreemfs.pbrpc.serviceRegisterRespons"
- "e\"\007\215\265\030\013\000\000\000\022[\n\023xtreemfs_checkpoint\022\034.xtre"
- "emfs.pbrpc.emptyRequest\032\035.xtreemfs.pbrpc"
- ".emptyResponse\"\007\215\265\030\024\000\000\000\022Y\n\021xtreemfs_shut"
- "down\022\034.xtreemfs.pbrpc.emptyRequest\032\035.xtr"
- "eemfs.pbrpc.emptyResponse\"\007\215\265\030\025\000\000\000\022m\n\032xt"
- "reemfs_configuration_get\022\'.xtreemfs.pbrp"
- "c.configurationGetRequest\032\035.xtreemfs.pbr"
- "pc.Configuration\"\007\215\265\030\026\000\000\000\022n\n\032xtreemfs_co"
- "nfiguration_set\022\035.xtreemfs.pbrpc.Configu"
- "ration\032(.xtreemfs.pbrpc.configurationSet"
- "Response\"\007\215\265\030\027\000\000\000\022l\n\036xtreemfs_vivaldi_cl"
- "ient_update\022\".xtreemfs.pbrpc.VivaldiCoor"
- "dinates\032\035.xtreemfs.pbrpc.emptyResponse\"\007"
- "\215\265\030\030\000\000\000\032\007\225\265\030\021\'\000\000B(\n&org.xtreemfs.pbrpc.g"
- "eneratedinterfaces", 3458);
+ "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();
@@ -631,7 +636,6 @@ struct 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_;
@@ -642,6 +646,7 @@ bool ServiceType_IsValid(int value) {
case 1:
case 2:
case 3:
+ case 4:
return true;
default:
return false;
@@ -666,11 +671,6 @@ bool ServiceStatus_IsValid(int value) {
// ===================================================================
-const ::std::string AddressMapping::_default_uuid_;
-const ::std::string AddressMapping::_default_protocol_;
-const ::std::string AddressMapping::_default_address_;
-const ::std::string AddressMapping::_default_match_network_;
-const ::std::string AddressMapping::_default_uri_;
#ifndef _MSC_VER
const int AddressMapping::kUuidFieldNumber;
const int AddressMapping::kVersionFieldNumber;
@@ -698,14 +698,14 @@ AddressMapping::AddressMapping(const AddressMapping& from)
void AddressMapping::SharedCtor() {
_cached_size_ = 0;
- uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
version_ = GOOGLE_ULONGLONG(0);
- protocol_ = const_cast< ::std::string*>(&_default_protocol_);
- address_ = const_cast< ::std::string*>(&_default_address_);
+ 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*>(&_default_match_network_);
+ match_network_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
ttl_s_ = 0u;
- uri_ = const_cast< ::std::string*>(&_default_uri_);
+ uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -714,19 +714,19 @@ AddressMapping::~AddressMapping() {
}
void AddressMapping::SharedDtor() {
- if (uuid_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
delete uuid_;
}
- if (protocol_ != &_default_protocol_) {
+ if (protocol_ != &::google::protobuf::internal::kEmptyString) {
delete protocol_;
}
- if (address_ != &_default_address_) {
+ if (address_ != &::google::protobuf::internal::kEmptyString) {
delete address_;
}
- if (match_network_ != &_default_match_network_) {
+ if (match_network_ != &::google::protobuf::internal::kEmptyString) {
delete match_network_;
}
- if (uri_ != &_default_uri_) {
+ if (uri_ != &::google::protobuf::internal::kEmptyString) {
delete uri_;
}
if (this != default_instance_) {
@@ -744,7 +744,8 @@ const ::google::protobuf::Descriptor* AddressMapping::descriptor() {
}
const AddressMapping& AddressMapping::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
AddressMapping* AddressMapping::default_instance_ = NULL;
@@ -755,31 +756,31 @@ AddressMapping* AddressMapping::New() const {
void AddressMapping::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (uuid_ != &_default_uuid_) {
+ if (has_uuid()) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
}
version_ = GOOGLE_ULONGLONG(0);
- if (_has_bit(2)) {
- if (protocol_ != &_default_protocol_) {
+ if (has_protocol()) {
+ if (protocol_ != &::google::protobuf::internal::kEmptyString) {
protocol_->clear();
}
}
- if (_has_bit(3)) {
- if (address_ != &_default_address_) {
+ if (has_address()) {
+ if (address_ != &::google::protobuf::internal::kEmptyString) {
address_->clear();
}
}
port_ = 0u;
- if (_has_bit(5)) {
- if (match_network_ != &_default_match_network_) {
+ if (has_match_network()) {
+ if (match_network_ != &::google::protobuf::internal::kEmptyString) {
match_network_->clear();
}
}
ttl_s_ = 0u;
- if (_has_bit(7)) {
- if (uri_ != &_default_uri_) {
+ if (has_uri()) {
+ if (uri_ != &::google::protobuf::internal::kEmptyString) {
uri_->clear();
}
}
@@ -809,7 +810,7 @@ bool AddressMapping::MergePartialFromCodedStream(
if (input->ExpectTag(17)) goto parse_version;
break;
}
-
+
// required fixed64 version = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -818,14 +819,14 @@ bool AddressMapping::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &version_)));
- _set_bit(1);
+ 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) ==
@@ -842,7 +843,7 @@ bool AddressMapping::MergePartialFromCodedStream(
if (input->ExpectTag(34)) goto parse_address;
break;
}
-
+
// required string address = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -859,7 +860,7 @@ bool AddressMapping::MergePartialFromCodedStream(
if (input->ExpectTag(45)) goto parse_port;
break;
}
-
+
// required fixed32 port = 5;
case 5: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -868,14 +869,14 @@ bool AddressMapping::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &port_)));
- _set_bit(4);
+ 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) ==
@@ -892,7 +893,7 @@ bool AddressMapping::MergePartialFromCodedStream(
if (input->ExpectTag(61)) goto parse_ttl_s;
break;
}
-
+
// required fixed32 ttl_s = 7;
case 7: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -901,14 +902,14 @@ bool AddressMapping::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &ttl_s_)));
- _set_bit(6);
+ 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) ==
@@ -925,7 +926,7 @@ bool AddressMapping::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -945,65 +946,65 @@ bool AddressMapping::MergePartialFromCodedStream(
void AddressMapping::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_version()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->version(), output);
}
-
+
// required string protocol = 3;
- if (_has_bit(2)) {
+ 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_bit(3)) {
+ 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_bit(4)) {
+ if (has_port()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->port(), output);
}
-
+
// required string match_network = 6;
- if (_has_bit(5)) {
+ 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_bit(6)) {
+ if (has_ttl_s()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(7, this->ttl_s(), output);
}
-
+
// required string uri = 8;
- if (_has_bit(7)) {
+ 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);
@@ -1013,7 +1014,7 @@ void AddressMapping::SerializeWithCachedSizes(
::google::protobuf::uint8* AddressMapping::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ if (has_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->uuid().data(), this->uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1021,14 +1022,14 @@ void AddressMapping::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->uuid(), target);
}
-
+
// required fixed64 version = 2;
- if (_has_bit(1)) {
+ if (has_version()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->version(), target);
}
-
+
// required string protocol = 3;
- if (_has_bit(2)) {
+ if (has_protocol()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->protocol().data(), this->protocol().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1036,9 +1037,9 @@ void AddressMapping::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->protocol(), target);
}
-
+
// required string address = 4;
- if (_has_bit(3)) {
+ if (has_address()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->address().data(), this->address().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1046,14 +1047,14 @@ void AddressMapping::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->address(), target);
}
-
+
// required fixed32 port = 5;
- if (_has_bit(4)) {
+ if (has_port()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->port(), target);
}
-
+
// required string match_network = 6;
- if (_has_bit(5)) {
+ if (has_match_network()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->match_network().data(), this->match_network().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1061,14 +1062,14 @@ void AddressMapping::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6, this->match_network(), target);
}
-
+
// required fixed32 ttl_s = 7;
- if (_has_bit(6)) {
+ if (has_ttl_s()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(7, this->ttl_s(), target);
}
-
+
// required string uri = 8;
- if (_has_bit(7)) {
+ if (has_uri()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->uri().data(), this->uri().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1076,7 +1077,7 @@ void AddressMapping::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
8, this->uri(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -1086,7 +1087,7 @@ void AddressMapping::SerializeWithCachedSizes(
int AddressMapping::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string uuid = 1;
if (has_uuid()) {
@@ -1094,50 +1095,50 @@ int AddressMapping::ByteSize() const {
::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 +=
@@ -1165,28 +1166,28 @@ void AddressMapping::MergeFrom(const ::google::protobuf::Message& from) {
void AddressMapping::MergeFrom(const AddressMapping& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_uuid()) {
set_uuid(from.uuid());
}
- if (from._has_bit(1)) {
+ if (from.has_version()) {
set_version(from.version());
}
- if (from._has_bit(2)) {
+ if (from.has_protocol()) {
set_protocol(from.protocol());
}
- if (from._has_bit(3)) {
+ if (from.has_address()) {
set_address(from.address());
}
- if (from._has_bit(4)) {
+ if (from.has_port()) {
set_port(from.port());
}
- if (from._has_bit(5)) {
+ if (from.has_match_network()) {
set_match_network(from.match_network());
}
- if (from._has_bit(6)) {
+ if (from.has_ttl_s()) {
set_ttl_s(from.ttl_s());
}
- if (from._has_bit(7)) {
+ if (from.has_uri()) {
set_uri(from.uri());
}
}
@@ -1207,7 +1208,7 @@ void AddressMapping::CopyFrom(const AddressMapping& from) {
bool AddressMapping::IsInitialized() const {
if ((_has_bits_[0] & 0x000000ff) != 0x000000ff) return false;
-
+
return true;
}
@@ -1281,7 +1282,8 @@ const ::google::protobuf::Descriptor* AddressMappingSet::descriptor() {
}
const AddressMappingSet& AddressMappingSet::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
AddressMappingSet* AddressMappingSet::default_instance_ = NULL;
@@ -1316,7 +1318,7 @@ bool AddressMappingSet::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1340,7 +1342,7 @@ void AddressMappingSet::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->mappings(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -1355,7 +1357,7 @@ void AddressMappingSet::SerializeWithCachedSizes(
WriteMessageNoVirtualToArray(
1, this->mappings(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -1365,7 +1367,7 @@ void AddressMappingSet::SerializeWithCachedSizes(
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++) {
@@ -1373,7 +1375,7 @@ int AddressMappingSet::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->mappings(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -1416,7 +1418,7 @@ void AddressMappingSet::CopyFrom(const AddressMappingSet& from) {
}
bool AddressMappingSet::IsInitialized() const {
-
+
for (int i = 0; i < mappings_size(); i++) {
if (!this->mappings(i).IsInitialized()) return false;
}
@@ -1443,8 +1445,6 @@ void AddressMappingSet::Swap(AddressMappingSet* other) {
// ===================================================================
-const ::std::string DirService::_default_address_;
-const ::std::string DirService::_default_protocol_;
#ifndef _MSC_VER
const int DirService::kAddressFieldNumber;
const int DirService::kPortFieldNumber;
@@ -1468,9 +1468,9 @@ DirService::DirService(const DirService& from)
void DirService::SharedCtor() {
_cached_size_ = 0;
- address_ = const_cast< ::std::string*>(&_default_address_);
+ address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
port_ = 0u;
- protocol_ = const_cast< ::std::string*>(&_default_protocol_);
+ protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
interface_version_ = 0u;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -1480,10 +1480,10 @@ DirService::~DirService() {
}
void DirService::SharedDtor() {
- if (address_ != &_default_address_) {
+ if (address_ != &::google::protobuf::internal::kEmptyString) {
delete address_;
}
- if (protocol_ != &_default_protocol_) {
+ if (protocol_ != &::google::protobuf::internal::kEmptyString) {
delete protocol_;
}
if (this != default_instance_) {
@@ -1501,7 +1501,8 @@ const ::google::protobuf::Descriptor* DirService::descriptor() {
}
const DirService& DirService::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
DirService* DirService::default_instance_ = NULL;
@@ -1512,14 +1513,14 @@ DirService* DirService::New() const {
void DirService::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (address_ != &_default_address_) {
+ if (has_address()) {
+ if (address_ != &::google::protobuf::internal::kEmptyString) {
address_->clear();
}
}
port_ = 0u;
- if (_has_bit(2)) {
- if (protocol_ != &_default_protocol_) {
+ if (has_protocol()) {
+ if (protocol_ != &::google::protobuf::internal::kEmptyString) {
protocol_->clear();
}
}
@@ -1550,7 +1551,7 @@ bool DirService::MergePartialFromCodedStream(
if (input->ExpectTag(21)) goto parse_port;
break;
}
-
+
// required fixed32 port = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1559,14 +1560,14 @@ bool DirService::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &port_)));
- _set_bit(1);
+ 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) ==
@@ -1583,7 +1584,7 @@ bool DirService::MergePartialFromCodedStream(
if (input->ExpectTag(37)) goto parse_interface_version;
break;
}
-
+
// required fixed32 interface_version = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1592,14 +1593,14 @@ bool DirService::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &interface_version_)));
- _set_bit(3);
+ set_has_interface_version();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1619,33 +1620,33 @@ bool DirService::MergePartialFromCodedStream(
void DirService::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string address = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_port()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->port(), output);
}
-
+
// required string protocol = 3;
- if (_has_bit(2)) {
+ 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_bit(3)) {
+ 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);
@@ -1655,7 +1656,7 @@ void DirService::SerializeWithCachedSizes(
::google::protobuf::uint8* DirService::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string address = 1;
- if (_has_bit(0)) {
+ if (has_address()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->address().data(), this->address().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1663,14 +1664,14 @@ void DirService::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->address(), target);
}
-
+
// required fixed32 port = 2;
- if (_has_bit(1)) {
+ if (has_port()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->port(), target);
}
-
+
// required string protocol = 3;
- if (_has_bit(2)) {
+ if (has_protocol()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->protocol().data(), this->protocol().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -1678,12 +1679,12 @@ void DirService::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->protocol(), target);
}
-
+
// required fixed32 interface_version = 4;
- if (_has_bit(3)) {
+ 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);
@@ -1693,7 +1694,7 @@ void DirService::SerializeWithCachedSizes(
int DirService::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string address = 1;
if (has_address()) {
@@ -1701,24 +1702,24 @@ int DirService::ByteSize() const {
::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 +=
@@ -1746,16 +1747,16 @@ void DirService::MergeFrom(const ::google::protobuf::Message& from) {
void DirService::MergeFrom(const DirService& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_address()) {
set_address(from.address());
}
- if (from._has_bit(1)) {
+ if (from.has_port()) {
set_port(from.port());
}
- if (from._has_bit(2)) {
+ if (from.has_protocol()) {
set_protocol(from.protocol());
}
- if (from._has_bit(3)) {
+ if (from.has_interface_version()) {
set_interface_version(from.interface_version());
}
}
@@ -1776,7 +1777,7 @@ void DirService::CopyFrom(const DirService& from) {
bool DirService::IsInitialized() const {
if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
-
+
return true;
}
@@ -1846,7 +1847,8 @@ const ::google::protobuf::Descriptor* ServiceDataMap::descriptor() {
}
const ServiceDataMap& ServiceDataMap::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
ServiceDataMap* ServiceDataMap::default_instance_ = NULL;
@@ -1881,7 +1883,7 @@ bool ServiceDataMap::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1905,7 +1907,7 @@ void ServiceDataMap::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->data(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -1920,7 +1922,7 @@ void ServiceDataMap::SerializeWithCachedSizes(
WriteMessageNoVirtualToArray(
1, this->data(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -1930,7 +1932,7 @@ void ServiceDataMap::SerializeWithCachedSizes(
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++) {
@@ -1938,7 +1940,7 @@ int ServiceDataMap::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->data(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -1981,7 +1983,7 @@ void ServiceDataMap::CopyFrom(const ServiceDataMap& from) {
}
bool ServiceDataMap::IsInitialized() const {
-
+
for (int i = 0; i < data_size(); i++) {
if (!this->data(i).IsInitialized()) return false;
}
@@ -2008,8 +2010,6 @@ void ServiceDataMap::Swap(ServiceDataMap* other) {
// ===================================================================
-const ::std::string Service::_default_uuid_;
-const ::std::string Service::_default_name_;
#ifndef _MSC_VER
const int Service::kTypeFieldNumber;
const int Service::kUuidFieldNumber;
@@ -2037,9 +2037,9 @@ Service::Service(const Service& from)
void Service::SharedCtor() {
_cached_size_ = 0;
type_ = 0;
- uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
version_ = GOOGLE_ULONGLONG(0);
- name_ = const_cast< ::std::string*>(&_default_name_);
+ name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
last_updated_s_ = GOOGLE_ULONGLONG(0);
data_ = NULL;
::memset(_has_bits_, 0, sizeof(_has_bits_));
@@ -2050,10 +2050,10 @@ Service::~Service() {
}
void Service::SharedDtor() {
- if (uuid_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
delete uuid_;
}
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
if (this != default_instance_) {
@@ -2072,7 +2072,8 @@ const ::google::protobuf::Descriptor* Service::descriptor() {
}
const Service& Service::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
Service* Service::default_instance_ = NULL;
@@ -2084,19 +2085,19 @@ Service* Service::New() const {
void Service::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
type_ = 0;
- if (_has_bit(1)) {
- if (uuid_ != &_default_uuid_) {
+ if (has_uuid()) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
}
version_ = GOOGLE_ULONGLONG(0);
- if (_has_bit(3)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
last_updated_s_ = GOOGLE_ULONGLONG(0);
- if (_has_bit(5)) {
+ if (has_data()) {
if (data_ != NULL) data_->::xtreemfs::pbrpc::ServiceDataMap::Clear();
}
}
@@ -2118,8 +2119,8 @@ bool Service::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::ServiceType_IsValid(value)) {
+ set_type(static_cast< ::xtreemfs::pbrpc::ServiceType >(value));
} else {
mutable_unknown_fields()->AddVarint(1, value);
}
@@ -2129,7 +2130,7 @@ bool Service::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_uuid;
break;
}
-
+
// required string uuid = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2146,7 +2147,7 @@ bool Service::MergePartialFromCodedStream(
if (input->ExpectTag(25)) goto parse_version;
break;
}
-
+
// required fixed64 version = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2155,14 +2156,14 @@ bool Service::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &version_)));
- _set_bit(2);
+ 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) ==
@@ -2179,7 +2180,7 @@ bool Service::MergePartialFromCodedStream(
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) ==
@@ -2188,14 +2189,14 @@ bool Service::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &last_updated_s_)));
- _set_bit(4);
+ 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) ==
@@ -2209,7 +2210,7 @@ bool Service::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2229,45 +2230,45 @@ bool Service::MergePartialFromCodedStream(
void Service::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.ServiceType type = 1;
- if (_has_bit(0)) {
+ if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
1, this->type(), output);
}
-
+
// required string uuid = 2;
- if (_has_bit(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(
2, this->uuid(), output);
}
-
+
// required fixed64 version = 3;
- if (_has_bit(2)) {
+ if (has_version()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output);
}
-
+
// required string name = 4;
- if (_has_bit(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(
4, this->name(), output);
}
-
+
// required fixed64 last_updated_s = 5;
- if (_has_bit(4)) {
+ if (has_last_updated_s()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(5, this->last_updated_s(), output);
}
-
+
// required .xtreemfs.pbrpc.ServiceDataMap data = 6;
- if (_has_bit(5)) {
+ if (has_data()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
6, this->data(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -2277,13 +2278,13 @@ void Service::SerializeWithCachedSizes(
::google::protobuf::uint8* Service::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.ServiceType type = 1;
- if (_has_bit(0)) {
+ if (has_type()) {
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1, this->type(), target);
}
-
+
// required string uuid = 2;
- if (_has_bit(1)) {
+ if (has_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->uuid().data(), this->uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2291,14 +2292,14 @@ void Service::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->uuid(), target);
}
-
+
// required fixed64 version = 3;
- if (_has_bit(2)) {
+ if (has_version()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target);
}
-
+
// required string name = 4;
- if (_has_bit(3)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2306,19 +2307,19 @@ void Service::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->name(), target);
}
-
+
// required fixed64 last_updated_s = 5;
- if (_has_bit(4)) {
+ 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_bit(5)) {
+ 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);
@@ -2328,45 +2329,45 @@ void Service::SerializeWithCachedSizes(
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 +=
@@ -2394,22 +2395,22 @@ void Service::MergeFrom(const ::google::protobuf::Message& from) {
void Service::MergeFrom(const Service& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_type()) {
set_type(from.type());
}
- if (from._has_bit(1)) {
+ if (from.has_uuid()) {
set_uuid(from.uuid());
}
- if (from._has_bit(2)) {
+ if (from.has_version()) {
set_version(from.version());
}
- if (from._has_bit(3)) {
+ if (from.has_name()) {
set_name(from.name());
}
- if (from._has_bit(4)) {
+ if (from.has_last_updated_s()) {
set_last_updated_s(from.last_updated_s());
}
- if (from._has_bit(5)) {
+ if (from.has_data()) {
mutable_data()->::xtreemfs::pbrpc::ServiceDataMap::MergeFrom(from.data());
}
}
@@ -2430,7 +2431,7 @@ void Service::CopyFrom(const Service& from) {
bool Service::IsInitialized() const {
if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;
-
+
if (has_data()) {
if (!this->data().IsInitialized()) return false;
}
@@ -2505,7 +2506,8 @@ const ::google::protobuf::Descriptor* ServiceSet::descriptor() {
}
const ServiceSet& ServiceSet::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
ServiceSet* ServiceSet::default_instance_ = NULL;
@@ -2540,7 +2542,7 @@ bool ServiceSet::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2564,7 +2566,7 @@ void ServiceSet::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->services(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -2579,7 +2581,7 @@ void ServiceSet::SerializeWithCachedSizes(
WriteMessageNoVirtualToArray(
1, this->services(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -2589,7 +2591,7 @@ void ServiceSet::SerializeWithCachedSizes(
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++) {
@@ -2597,7 +2599,7 @@ int ServiceSet::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->services(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2640,7 +2642,7 @@ void ServiceSet::CopyFrom(const ServiceSet& from) {
}
bool ServiceSet::IsInitialized() const {
-
+
for (int i = 0; i < services_size(); i++) {
if (!this->services(i).IsInitialized()) return false;
}
@@ -2667,7 +2669,6 @@ void ServiceSet::Swap(ServiceSet* other) {
// ===================================================================
-const ::std::string Configuration::_default_uuid_;
#ifndef _MSC_VER
const int Configuration::kUuidFieldNumber;
const int Configuration::kParameterFieldNumber;
@@ -2690,7 +2691,7 @@ Configuration::Configuration(const Configuration& from)
void Configuration::SharedCtor() {
_cached_size_ = 0;
- uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
version_ = GOOGLE_ULONGLONG(0);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -2700,7 +2701,7 @@ Configuration::~Configuration() {
}
void Configuration::SharedDtor() {
- if (uuid_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
delete uuid_;
}
if (this != default_instance_) {
@@ -2718,7 +2719,8 @@ const ::google::protobuf::Descriptor* Configuration::descriptor() {
}
const Configuration& Configuration::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
Configuration* Configuration::default_instance_ = NULL;
@@ -2729,8 +2731,8 @@ Configuration* Configuration::New() const {
void Configuration::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (uuid_ != &_default_uuid_) {
+ if (has_uuid()) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
}
@@ -2762,7 +2764,7 @@ bool Configuration::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_parameter;
break;
}
-
+
// repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2777,7 +2779,7 @@ bool Configuration::MergePartialFromCodedStream(
if (input->ExpectTag(25)) goto parse_version;
break;
}
-
+
// required fixed64 version = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2786,14 +2788,14 @@ bool Configuration::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &version_)));
- _set_bit(2);
+ set_has_version();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2813,25 +2815,25 @@ bool Configuration::MergePartialFromCodedStream(
void Configuration::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ 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_bit(2)) {
+ if (has_version()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -2841,7 +2843,7 @@ void Configuration::SerializeWithCachedSizes(
::google::protobuf::uint8* Configuration::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ if (has_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->uuid().data(), this->uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2849,19 +2851,19 @@ void Configuration::SerializeWithCachedSizes(
::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_bit(2)) {
+ 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);
@@ -2871,7 +2873,7 @@ void Configuration::SerializeWithCachedSizes(
int Configuration::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string uuid = 1;
if (has_uuid()) {
@@ -2879,12 +2881,12 @@ int Configuration::ByteSize() const {
::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();
@@ -2893,7 +2895,7 @@ int Configuration::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->parameter(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2921,10 +2923,10 @@ 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_bit(0)) {
+ if (from.has_uuid()) {
set_uuid(from.uuid());
}
- if (from._has_bit(2)) {
+ if (from.has_version()) {
set_version(from.version());
}
}
@@ -2945,7 +2947,7 @@ void Configuration::CopyFrom(const Configuration& 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;
}
@@ -2974,7 +2976,6 @@ void Configuration::Swap(Configuration* other) {
// ===================================================================
-const ::std::string addressMappingGetRequest::_default_uuid_;
#ifndef _MSC_VER
const int addressMappingGetRequest::kUuidFieldNumber;
#endif // !_MSC_VER
@@ -2995,7 +2996,7 @@ addressMappingGetRequest::addressMappingGetRequest(const addressMappingGetReques
void addressMappingGetRequest::SharedCtor() {
_cached_size_ = 0;
- uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -3004,7 +3005,7 @@ addressMappingGetRequest::~addressMappingGetRequest() {
}
void addressMappingGetRequest::SharedDtor() {
- if (uuid_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
delete uuid_;
}
if (this != default_instance_) {
@@ -3022,7 +3023,8 @@ const ::google::protobuf::Descriptor* addressMappingGetRequest::descriptor() {
}
const addressMappingGetRequest& addressMappingGetRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
addressMappingGetRequest* addressMappingGetRequest::default_instance_ = NULL;
@@ -3033,8 +3035,8 @@ addressMappingGetRequest* addressMappingGetRequest::New() const {
void addressMappingGetRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (uuid_ != &_default_uuid_) {
+ if (has_uuid()) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
}
@@ -3064,7 +3066,7 @@ bool addressMappingGetRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3084,14 +3086,14 @@ bool addressMappingGetRequest::MergePartialFromCodedStream(
void addressMappingGetRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3101,7 +3103,7 @@ void addressMappingGetRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* addressMappingGetRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ if (has_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->uuid().data(), this->uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -3109,7 +3111,7 @@ void addressMappingGetRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->uuid(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -3119,7 +3121,7 @@ void addressMappingGetRequest::SerializeWithCachedSizes(
int addressMappingGetRequest::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string uuid = 1;
if (has_uuid()) {
@@ -3127,7 +3129,7 @@ int addressMappingGetRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->uuid());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -3155,7 +3157,7 @@ void addressMappingGetRequest::MergeFrom(const ::google::protobuf::Message& from
void addressMappingGetRequest::MergeFrom(const addressMappingGetRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_uuid()) {
set_uuid(from.uuid());
}
}
@@ -3176,7 +3178,7 @@ void addressMappingGetRequest::CopyFrom(const addressMappingGetRequest& from) {
bool addressMappingGetRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -3246,7 +3248,8 @@ const ::google::protobuf::Descriptor* addressMappingGetResponse::descriptor() {
}
const addressMappingGetResponse& addressMappingGetResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
addressMappingGetResponse* addressMappingGetResponse::default_instance_ = NULL;
@@ -3257,7 +3260,7 @@ addressMappingGetResponse* addressMappingGetResponse::New() const {
void addressMappingGetResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_result()) {
if (result_ != NULL) result_->::xtreemfs::pbrpc::AddressMappingSet::Clear();
}
}
@@ -3283,7 +3286,7 @@ bool addressMappingGetResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3303,11 +3306,11 @@ bool addressMappingGetResponse::MergePartialFromCodedStream(
void addressMappingGetResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
- if (_has_bit(0)) {
+ if (has_result()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->result(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -3317,12 +3320,12 @@ void addressMappingGetResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* addressMappingGetResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3332,7 +3335,7 @@ void addressMappingGetResponse::SerializeWithCachedSizes(
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()) {
@@ -3340,7 +3343,7 @@ int addressMappingGetResponse::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->result());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -3368,7 +3371,7 @@ void addressMappingGetResponse::MergeFrom(const ::google::protobuf::Message& fro
void addressMappingGetResponse::MergeFrom(const addressMappingGetResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_result()) {
mutable_result()->::xtreemfs::pbrpc::AddressMappingSet::MergeFrom(from.result());
}
}
@@ -3388,7 +3391,7 @@ void addressMappingGetResponse::CopyFrom(const addressMappingGetResponse& from)
}
bool addressMappingGetResponse::IsInitialized() const {
-
+
if (has_result()) {
if (!this->result().IsInitialized()) return false;
}
@@ -3459,7 +3462,8 @@ const ::google::protobuf::Descriptor* addressMappingSetResponse::descriptor() {
}
const addressMappingSetResponse& addressMappingSetResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
addressMappingSetResponse* addressMappingSetResponse::default_instance_ = NULL;
@@ -3489,14 +3493,14 @@ bool addressMappingSetResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &new_version_)));
- _set_bit(0);
+ set_has_new_version();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3516,10 +3520,10 @@ bool addressMappingSetResponse::MergePartialFromCodedStream(
void addressMappingSetResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional fixed64 new_version = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3529,10 +3533,10 @@ void addressMappingSetResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* addressMappingSetResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional fixed64 new_version = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3542,13 +3546,13 @@ void addressMappingSetResponse::SerializeWithCachedSizes(
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 +=
@@ -3576,7 +3580,7 @@ void addressMappingSetResponse::MergeFrom(const ::google::protobuf::Message& fro
void addressMappingSetResponse::MergeFrom(const addressMappingSetResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_new_version()) {
set_new_version(from.new_version());
}
}
@@ -3596,7 +3600,7 @@ void addressMappingSetResponse::CopyFrom(const addressMappingSetResponse& from)
}
bool addressMappingSetResponse::IsInitialized() const {
-
+
return true;
}
@@ -3664,7 +3668,8 @@ const ::google::protobuf::Descriptor* globalTimeSGetResponse::descriptor() {
}
const globalTimeSGetResponse& globalTimeSGetResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
globalTimeSGetResponse* globalTimeSGetResponse::default_instance_ = NULL;
@@ -3694,14 +3699,14 @@ bool globalTimeSGetResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &time_in_seconds_)));
- _set_bit(0);
+ 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) ==
@@ -3721,10 +3726,10 @@ bool globalTimeSGetResponse::MergePartialFromCodedStream(
void globalTimeSGetResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed64 time_in_seconds = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3734,10 +3739,10 @@ void globalTimeSGetResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* globalTimeSGetResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed64 time_in_seconds = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3747,13 +3752,13 @@ void globalTimeSGetResponse::SerializeWithCachedSizes(
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 +=
@@ -3781,7 +3786,7 @@ void globalTimeSGetResponse::MergeFrom(const ::google::protobuf::Message& from)
void globalTimeSGetResponse::MergeFrom(const globalTimeSGetResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_time_in_seconds()) {
set_time_in_seconds(from.time_in_seconds());
}
}
@@ -3802,7 +3807,7 @@ void globalTimeSGetResponse::CopyFrom(const globalTimeSGetResponse& from) {
bool globalTimeSGetResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -3826,7 +3831,6 @@ void globalTimeSGetResponse::Swap(globalTimeSGetResponse* other) {
// ===================================================================
-const ::std::string serviceDeregisterRequest::_default_uuid_;
#ifndef _MSC_VER
const int serviceDeregisterRequest::kUuidFieldNumber;
#endif // !_MSC_VER
@@ -3847,7 +3851,7 @@ serviceDeregisterRequest::serviceDeregisterRequest(const serviceDeregisterReques
void serviceDeregisterRequest::SharedCtor() {
_cached_size_ = 0;
- uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -3856,7 +3860,7 @@ serviceDeregisterRequest::~serviceDeregisterRequest() {
}
void serviceDeregisterRequest::SharedDtor() {
- if (uuid_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
delete uuid_;
}
if (this != default_instance_) {
@@ -3874,7 +3878,8 @@ const ::google::protobuf::Descriptor* serviceDeregisterRequest::descriptor() {
}
const serviceDeregisterRequest& serviceDeregisterRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
serviceDeregisterRequest* serviceDeregisterRequest::default_instance_ = NULL;
@@ -3885,8 +3890,8 @@ serviceDeregisterRequest* serviceDeregisterRequest::New() const {
void serviceDeregisterRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (uuid_ != &_default_uuid_) {
+ if (has_uuid()) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
}
@@ -3916,7 +3921,7 @@ bool serviceDeregisterRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3936,14 +3941,14 @@ bool serviceDeregisterRequest::MergePartialFromCodedStream(
void serviceDeregisterRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3953,7 +3958,7 @@ void serviceDeregisterRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* serviceDeregisterRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ if (has_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->uuid().data(), this->uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -3961,7 +3966,7 @@ void serviceDeregisterRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->uuid(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -3971,7 +3976,7 @@ void serviceDeregisterRequest::SerializeWithCachedSizes(
int serviceDeregisterRequest::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string uuid = 1;
if (has_uuid()) {
@@ -3979,7 +3984,7 @@ int serviceDeregisterRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->uuid());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -4007,7 +4012,7 @@ void serviceDeregisterRequest::MergeFrom(const ::google::protobuf::Message& from
void serviceDeregisterRequest::MergeFrom(const serviceDeregisterRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_uuid()) {
set_uuid(from.uuid());
}
}
@@ -4028,7 +4033,7 @@ void serviceDeregisterRequest::CopyFrom(const serviceDeregisterRequest& from) {
bool serviceDeregisterRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -4052,7 +4057,6 @@ void serviceDeregisterRequest::Swap(serviceDeregisterRequest* other) {
// ===================================================================
-const ::std::string serviceGetByNameRequest::_default_name_;
#ifndef _MSC_VER
const int serviceGetByNameRequest::kNameFieldNumber;
#endif // !_MSC_VER
@@ -4073,7 +4077,7 @@ serviceGetByNameRequest::serviceGetByNameRequest(const serviceGetByNameRequest&
void serviceGetByNameRequest::SharedCtor() {
_cached_size_ = 0;
- name_ = const_cast< ::std::string*>(&_default_name_);
+ name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -4082,7 +4086,7 @@ serviceGetByNameRequest::~serviceGetByNameRequest() {
}
void serviceGetByNameRequest::SharedDtor() {
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
if (this != default_instance_) {
@@ -4100,7 +4104,8 @@ const ::google::protobuf::Descriptor* serviceGetByNameRequest::descriptor() {
}
const serviceGetByNameRequest& serviceGetByNameRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
serviceGetByNameRequest* serviceGetByNameRequest::default_instance_ = NULL;
@@ -4111,8 +4116,8 @@ serviceGetByNameRequest* serviceGetByNameRequest::New() const {
void serviceGetByNameRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
@@ -4142,7 +4147,7 @@ bool serviceGetByNameRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -4162,14 +4167,14 @@ bool serviceGetByNameRequest::MergePartialFromCodedStream(
void serviceGetByNameRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string name = 1;
- if (_has_bit(0)) {
+ 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);
@@ -4179,7 +4184,7 @@ void serviceGetByNameRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* serviceGetByNameRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string name = 1;
- if (_has_bit(0)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -4187,7 +4192,7 @@ void serviceGetByNameRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -4197,7 +4202,7 @@ void serviceGetByNameRequest::SerializeWithCachedSizes(
int serviceGetByNameRequest::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string name = 1;
if (has_name()) {
@@ -4205,7 +4210,7 @@ int serviceGetByNameRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->name());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -4233,7 +4238,7 @@ void serviceGetByNameRequest::MergeFrom(const ::google::protobuf::Message& from)
void serviceGetByNameRequest::MergeFrom(const serviceGetByNameRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_name()) {
set_name(from.name());
}
}
@@ -4254,7 +4259,7 @@ void serviceGetByNameRequest::CopyFrom(const serviceGetByNameRequest& from) {
bool serviceGetByNameRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -4278,7 +4283,6 @@ void serviceGetByNameRequest::Swap(serviceGetByNameRequest* other) {
// ===================================================================
-const ::std::string serviceGetByUUIDRequest::_default_name_;
#ifndef _MSC_VER
const int serviceGetByUUIDRequest::kNameFieldNumber;
#endif // !_MSC_VER
@@ -4299,7 +4303,7 @@ serviceGetByUUIDRequest::serviceGetByUUIDRequest(const serviceGetByUUIDRequest&
void serviceGetByUUIDRequest::SharedCtor() {
_cached_size_ = 0;
- name_ = const_cast< ::std::string*>(&_default_name_);
+ name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -4308,7 +4312,7 @@ serviceGetByUUIDRequest::~serviceGetByUUIDRequest() {
}
void serviceGetByUUIDRequest::SharedDtor() {
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
if (this != default_instance_) {
@@ -4326,7 +4330,8 @@ const ::google::protobuf::Descriptor* serviceGetByUUIDRequest::descriptor() {
}
const serviceGetByUUIDRequest& serviceGetByUUIDRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
serviceGetByUUIDRequest* serviceGetByUUIDRequest::default_instance_ = NULL;
@@ -4337,8 +4342,8 @@ serviceGetByUUIDRequest* serviceGetByUUIDRequest::New() const {
void serviceGetByUUIDRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
@@ -4368,7 +4373,7 @@ bool serviceGetByUUIDRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -4388,14 +4393,14 @@ bool serviceGetByUUIDRequest::MergePartialFromCodedStream(
void serviceGetByUUIDRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string name = 1;
- if (_has_bit(0)) {
+ 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);
@@ -4405,7 +4410,7 @@ void serviceGetByUUIDRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* serviceGetByUUIDRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string name = 1;
- if (_has_bit(0)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -4413,7 +4418,7 @@ void serviceGetByUUIDRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -4423,7 +4428,7 @@ void serviceGetByUUIDRequest::SerializeWithCachedSizes(
int serviceGetByUUIDRequest::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string name = 1;
if (has_name()) {
@@ -4431,7 +4436,7 @@ int serviceGetByUUIDRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->name());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -4459,7 +4464,7 @@ void serviceGetByUUIDRequest::MergeFrom(const ::google::protobuf::Message& from)
void serviceGetByUUIDRequest::MergeFrom(const serviceGetByUUIDRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_name()) {
set_name(from.name());
}
}
@@ -4480,7 +4485,7 @@ void serviceGetByUUIDRequest::CopyFrom(const serviceGetByUUIDRequest& from) {
bool serviceGetByUUIDRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -4548,7 +4553,8 @@ const ::google::protobuf::Descriptor* serviceGetByTypeRequest::descriptor() {
}
const serviceGetByTypeRequest& serviceGetByTypeRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
serviceGetByTypeRequest* serviceGetByTypeRequest::default_instance_ = NULL;
@@ -4579,8 +4585,8 @@ bool serviceGetByTypeRequest::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::ServiceType_IsValid(value)) {
+ set_type(static_cast< ::xtreemfs::pbrpc::ServiceType >(value));
} else {
mutable_unknown_fields()->AddVarint(1, value);
}
@@ -4590,7 +4596,7 @@ bool serviceGetByTypeRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -4610,11 +4616,11 @@ bool serviceGetByTypeRequest::MergePartialFromCodedStream(
void serviceGetByTypeRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.ServiceType type = 1;
- if (_has_bit(0)) {
+ if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
1, this->type(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -4624,11 +4630,11 @@ void serviceGetByTypeRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* serviceGetByTypeRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.ServiceType type = 1;
- if (_has_bit(0)) {
+ 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);
@@ -4638,14 +4644,14 @@ void serviceGetByTypeRequest::SerializeWithCachedSizes(
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 +=
@@ -4673,7 +4679,7 @@ void serviceGetByTypeRequest::MergeFrom(const ::google::protobuf::Message& from)
void serviceGetByTypeRequest::MergeFrom(const serviceGetByTypeRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_type()) {
set_type(from.type());
}
}
@@ -4694,7 +4700,7 @@ void serviceGetByTypeRequest::CopyFrom(const serviceGetByTypeRequest& from) {
bool serviceGetByTypeRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -4764,7 +4770,8 @@ const ::google::protobuf::Descriptor* serviceRegisterRequest::descriptor() {
}
const serviceRegisterRequest& serviceRegisterRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
serviceRegisterRequest* serviceRegisterRequest::default_instance_ = NULL;
@@ -4775,7 +4782,7 @@ serviceRegisterRequest* serviceRegisterRequest::New() const {
void serviceRegisterRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_service()) {
if (service_ != NULL) service_->::xtreemfs::pbrpc::Service::Clear();
}
}
@@ -4801,7 +4808,7 @@ bool serviceRegisterRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -4821,11 +4828,11 @@ bool serviceRegisterRequest::MergePartialFromCodedStream(
void serviceRegisterRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.Service service = 1;
- if (_has_bit(0)) {
+ if (has_service()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->service(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -4835,12 +4842,12 @@ void serviceRegisterRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* serviceRegisterRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.Service service = 1;
- if (_has_bit(0)) {
+ 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);
@@ -4850,7 +4857,7 @@ void serviceRegisterRequest::SerializeWithCachedSizes(
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()) {
@@ -4858,7 +4865,7 @@ int serviceRegisterRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->service());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -4886,7 +4893,7 @@ void serviceRegisterRequest::MergeFrom(const ::google::protobuf::Message& from)
void serviceRegisterRequest::MergeFrom(const serviceRegisterRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_service()) {
mutable_service()->::xtreemfs::pbrpc::Service::MergeFrom(from.service());
}
}
@@ -4907,7 +4914,7 @@ void serviceRegisterRequest::CopyFrom(const serviceRegisterRequest& from) {
bool serviceRegisterRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
if (has_service()) {
if (!this->service().IsInitialized()) return false;
}
@@ -4978,7 +4985,8 @@ const ::google::protobuf::Descriptor* serviceRegisterResponse::descriptor() {
}
const serviceRegisterResponse& serviceRegisterResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
serviceRegisterResponse* serviceRegisterResponse::default_instance_ = NULL;
@@ -5008,14 +5016,14 @@ bool serviceRegisterResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &new_version_)));
- _set_bit(0);
+ set_has_new_version();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5035,10 +5043,10 @@ bool serviceRegisterResponse::MergePartialFromCodedStream(
void serviceRegisterResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed64 new_version = 1;
- if (_has_bit(0)) {
+ 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);
@@ -5048,10 +5056,10 @@ void serviceRegisterResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* serviceRegisterResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed64 new_version = 1;
- if (_has_bit(0)) {
+ 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);
@@ -5061,13 +5069,13 @@ void serviceRegisterResponse::SerializeWithCachedSizes(
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 +=
@@ -5095,7 +5103,7 @@ void serviceRegisterResponse::MergeFrom(const ::google::protobuf::Message& from)
void serviceRegisterResponse::MergeFrom(const serviceRegisterResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_new_version()) {
set_new_version(from.new_version());
}
}
@@ -5116,7 +5124,7 @@ void serviceRegisterResponse::CopyFrom(const serviceRegisterResponse& from) {
bool serviceRegisterResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -5140,7 +5148,6 @@ void serviceRegisterResponse::Swap(serviceRegisterResponse* other) {
// ===================================================================
-const ::std::string configurationGetRequest::_default_uuid_;
#ifndef _MSC_VER
const int configurationGetRequest::kUuidFieldNumber;
#endif // !_MSC_VER
@@ -5161,7 +5168,7 @@ configurationGetRequest::configurationGetRequest(const configurationGetRequest&
void configurationGetRequest::SharedCtor() {
_cached_size_ = 0;
- uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -5170,7 +5177,7 @@ configurationGetRequest::~configurationGetRequest() {
}
void configurationGetRequest::SharedDtor() {
- if (uuid_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
delete uuid_;
}
if (this != default_instance_) {
@@ -5188,7 +5195,8 @@ const ::google::protobuf::Descriptor* configurationGetRequest::descriptor() {
}
const configurationGetRequest& configurationGetRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
configurationGetRequest* configurationGetRequest::default_instance_ = NULL;
@@ -5199,8 +5207,8 @@ configurationGetRequest* configurationGetRequest::New() const {
void configurationGetRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (uuid_ != &_default_uuid_) {
+ if (has_uuid()) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
}
@@ -5230,7 +5238,7 @@ bool configurationGetRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5250,14 +5258,14 @@ bool configurationGetRequest::MergePartialFromCodedStream(
void configurationGetRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ 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);
@@ -5267,7 +5275,7 @@ void configurationGetRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* configurationGetRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string uuid = 1;
- if (_has_bit(0)) {
+ if (has_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->uuid().data(), this->uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -5275,7 +5283,7 @@ void configurationGetRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->uuid(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -5285,7 +5293,7 @@ void configurationGetRequest::SerializeWithCachedSizes(
int configurationGetRequest::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string uuid = 1;
if (has_uuid()) {
@@ -5293,7 +5301,7 @@ int configurationGetRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->uuid());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -5321,7 +5329,7 @@ void configurationGetRequest::MergeFrom(const ::google::protobuf::Message& from)
void configurationGetRequest::MergeFrom(const configurationGetRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_uuid()) {
set_uuid(from.uuid());
}
}
@@ -5342,7 +5350,7 @@ void configurationGetRequest::CopyFrom(const configurationGetRequest& from) {
bool configurationGetRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -5410,7 +5418,8 @@ const ::google::protobuf::Descriptor* configurationSetResponse::descriptor() {
}
const configurationSetResponse& configurationSetResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ return *default_instance_;
}
configurationSetResponse* configurationSetResponse::default_instance_ = NULL;
@@ -5440,14 +5449,14 @@ bool configurationSetResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &new_version_)));
- _set_bit(0);
+ set_has_new_version();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5467,10 +5476,10 @@ bool configurationSetResponse::MergePartialFromCodedStream(
void configurationSetResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional fixed64 new_version = 1;
- if (_has_bit(0)) {
+ 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);
@@ -5480,10 +5489,10 @@ void configurationSetResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* configurationSetResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional fixed64 new_version = 1;
- if (_has_bit(0)) {
+ 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);
@@ -5493,13 +5502,13 @@ void configurationSetResponse::SerializeWithCachedSizes(
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 +=
@@ -5527,7 +5536,7 @@ void configurationSetResponse::MergeFrom(const ::google::protobuf::Message& from
void configurationSetResponse::MergeFrom(const configurationSetResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_new_version()) {
set_new_version(from.new_version());
}
}
@@ -5547,7 +5556,7 @@ void configurationSetResponse::CopyFrom(const configurationSetResponse& from) {
}
bool configurationSetResponse::IsInitialized() const {
-
+
return true;
}
@@ -5569,465 +5578,6 @@ void configurationSetResponse::Swap(configurationSetResponse* other) {
}
-// ===================================================================
-
-DirectoryService::~DirectoryService() {}
-
-const ::google::protobuf::ServiceDescriptor* DirectoryService::descriptor() {
- protobuf_AssignDescriptorsOnce();
- return DirectoryService_descriptor_;
-}
-
-const ::google::protobuf::ServiceDescriptor* DirectoryService::GetDescriptor() {
- protobuf_AssignDescriptorsOnce();
- return DirectoryService_descriptor_;
-}
-
-void DirectoryService::xtreemfs_address_mappings_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::addressMappingGetRequest*,
- ::xtreemfs::pbrpc::AddressMappingSet*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_address_mappings_get() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_address_mappings_remove(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::addressMappingGetRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_address_mappings_remove() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_address_mappings_set(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::AddressMappingSet*,
- ::xtreemfs::pbrpc::addressMappingSetResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_address_mappings_set() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_discover_dir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest*,
- ::xtreemfs::pbrpc::DirService*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_discover_dir() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_global_time_s_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest*,
- ::xtreemfs::pbrpc::globalTimeSGetResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_global_time_s_get() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_service_deregister(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceDeregisterRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_service_deregister() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_service_get_by_name(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByNameRequest*,
- ::xtreemfs::pbrpc::ServiceSet*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_service_get_by_name() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_service_get_by_type(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByTypeRequest*,
- ::xtreemfs::pbrpc::ServiceSet*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_service_get_by_type() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_service_get_by_uuid(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByUUIDRequest*,
- ::xtreemfs::pbrpc::ServiceSet*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_service_get_by_uuid() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_service_offline(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByUUIDRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_service_offline() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_service_register(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceRegisterRequest*,
- ::xtreemfs::pbrpc::serviceRegisterResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_service_register() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_checkpoint(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_checkpoint() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_shutdown(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_shutdown() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_configuration_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::configurationGetRequest*,
- ::xtreemfs::pbrpc::Configuration*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_configuration_get() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_configuration_set(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Configuration*,
- ::xtreemfs::pbrpc::configurationSetResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_configuration_set() not implemented.");
- done->Run();
-}
-
-void DirectoryService::xtreemfs_vivaldi_client_update(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::VivaldiCoordinates*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_vivaldi_client_update() not implemented.");
- done->Run();
-}
-
-void DirectoryService::CallMethod(const ::google::protobuf::MethodDescriptor* method,
- ::google::protobuf::RpcController* controller,
- const ::google::protobuf::Message* request,
- ::google::protobuf::Message* response,
- ::google::protobuf::Closure* done) {
- GOOGLE_DCHECK_EQ(method->service(), DirectoryService_descriptor_);
- switch(method->index()) {
- case 0:
- xtreemfs_address_mappings_get(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::AddressMappingSet*>(response),
- done);
- break;
- case 1:
- xtreemfs_address_mappings_remove(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 2:
- xtreemfs_address_mappings_set(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::addressMappingSetResponse*>(response),
- done);
- break;
- case 3:
- xtreemfs_discover_dir(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::DirService*>(response),
- done);
- break;
- case 4:
- xtreemfs_global_time_s_get(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::globalTimeSGetResponse*>(response),
- done);
- break;
- case 5:
- xtreemfs_service_deregister(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 6:
- xtreemfs_service_get_by_name(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::ServiceSet*>(response),
- done);
- break;
- case 7:
- xtreemfs_service_get_by_type(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::ServiceSet*>(response),
- done);
- break;
- case 8:
- xtreemfs_service_get_by_uuid(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::ServiceSet*>(response),
- done);
- break;
- case 9:
- xtreemfs_service_offline(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 10:
- xtreemfs_service_register(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::serviceRegisterResponse*>(response),
- done);
- break;
- case 11:
- xtreemfs_checkpoint(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 12:
- xtreemfs_shutdown(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 13:
- xtreemfs_configuration_get(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::Configuration*>(response),
- done);
- break;
- case 14:
- xtreemfs_configuration_set(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::configurationSetResponse*>(response),
- done);
- break;
- case 15:
- xtreemfs_vivaldi_client_update(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- break;
- }
-}
-
-const ::google::protobuf::Message& DirectoryService::GetRequestPrototype(
- const ::google::protobuf::MethodDescriptor* method) const {
- GOOGLE_DCHECK_EQ(method->service(), descriptor());
- switch(method->index()) {
- case 0:
- return ::xtreemfs::pbrpc::addressMappingGetRequest::default_instance();
- case 1:
- return ::xtreemfs::pbrpc::addressMappingGetRequest::default_instance();
- case 2:
- return ::xtreemfs::pbrpc::AddressMappingSet::default_instance();
- case 3:
- return ::xtreemfs::pbrpc::emptyRequest::default_instance();
- case 4:
- return ::xtreemfs::pbrpc::emptyRequest::default_instance();
- case 5:
- return ::xtreemfs::pbrpc::serviceDeregisterRequest::default_instance();
- case 6:
- return ::xtreemfs::pbrpc::serviceGetByNameRequest::default_instance();
- case 7:
- return ::xtreemfs::pbrpc::serviceGetByTypeRequest::default_instance();
- case 8:
- return ::xtreemfs::pbrpc::serviceGetByUUIDRequest::default_instance();
- case 9:
- return ::xtreemfs::pbrpc::serviceGetByUUIDRequest::default_instance();
- case 10:
- return ::xtreemfs::pbrpc::serviceRegisterRequest::default_instance();
- case 11:
- return ::xtreemfs::pbrpc::emptyRequest::default_instance();
- case 12:
- return ::xtreemfs::pbrpc::emptyRequest::default_instance();
- case 13:
- return ::xtreemfs::pbrpc::configurationGetRequest::default_instance();
- case 14:
- return ::xtreemfs::pbrpc::Configuration::default_instance();
- case 15:
- return ::xtreemfs::pbrpc::VivaldiCoordinates::default_instance();
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- return *reinterpret_cast< ::google::protobuf::Message*>(NULL);
- }
-}
-
-const ::google::protobuf::Message& DirectoryService::GetResponsePrototype(
- const ::google::protobuf::MethodDescriptor* method) const {
- GOOGLE_DCHECK_EQ(method->service(), descriptor());
- switch(method->index()) {
- case 0:
- return ::xtreemfs::pbrpc::AddressMappingSet::default_instance();
- case 1:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 2:
- return ::xtreemfs::pbrpc::addressMappingSetResponse::default_instance();
- case 3:
- return ::xtreemfs::pbrpc::DirService::default_instance();
- case 4:
- return ::xtreemfs::pbrpc::globalTimeSGetResponse::default_instance();
- case 5:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 6:
- return ::xtreemfs::pbrpc::ServiceSet::default_instance();
- case 7:
- return ::xtreemfs::pbrpc::ServiceSet::default_instance();
- case 8:
- return ::xtreemfs::pbrpc::ServiceSet::default_instance();
- case 9:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 10:
- return ::xtreemfs::pbrpc::serviceRegisterResponse::default_instance();
- case 11:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 12:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 13:
- return ::xtreemfs::pbrpc::Configuration::default_instance();
- case 14:
- return ::xtreemfs::pbrpc::configurationSetResponse::default_instance();
- case 15:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- return *reinterpret_cast< ::google::protobuf::Message*>(NULL);
- }
-}
-
-DirectoryService_Stub::DirectoryService_Stub(::google::protobuf::RpcChannel* channel)
- : channel_(channel), owns_channel_(false) {}
-DirectoryService_Stub::DirectoryService_Stub(
- ::google::protobuf::RpcChannel* channel,
- ::google::protobuf::Service::ChannelOwnership ownership)
- : channel_(channel),
- owns_channel_(ownership == ::google::protobuf::Service::STUB_OWNS_CHANNEL) {}
-DirectoryService_Stub::~DirectoryService_Stub() {
- if (owns_channel_) delete channel_;
-}
-
-void DirectoryService_Stub::xtreemfs_address_mappings_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::addressMappingGetRequest* request,
- ::xtreemfs::pbrpc::AddressMappingSet* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(0),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_address_mappings_remove(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::addressMappingGetRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(1),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_address_mappings_set(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::AddressMappingSet* request,
- ::xtreemfs::pbrpc::addressMappingSetResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(2),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_discover_dir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::DirService* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(3),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_global_time_s_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::globalTimeSGetResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(4),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_service_deregister(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceDeregisterRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(5),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_service_get_by_name(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByNameRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(6),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_service_get_by_type(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByTypeRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(7),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_service_get_by_uuid(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByUUIDRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(8),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_service_offline(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByUUIDRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(9),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_service_register(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceRegisterRequest* request,
- ::xtreemfs::pbrpc::serviceRegisterResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(10),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_checkpoint(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(11),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_shutdown(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(12),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_configuration_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::configurationGetRequest* request,
- ::xtreemfs::pbrpc::Configuration* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(13),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_configuration_set(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Configuration* request,
- ::xtreemfs::pbrpc::configurationSetResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(14),
- controller, request, response, done);
-}
-void DirectoryService_Stub::xtreemfs_vivaldi_client_update(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::VivaldiCoordinates* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(15),
- controller, request, response, done);
-}
-
// @@protoc_insertion_point(namespace_scope)
} // namespace pbrpc
diff --git a/cpp/generated/xtreemfs/DIR.pb.h b/cpp/generated/xtreemfs/DIR.pb.h
index f43b05d14965d235dc2e8c63db3def3f3ea81b98..0dbba4451a911b4658dee8aaa79aadc705fad4e9 100644
--- a/cpp/generated/xtreemfs/DIR.pb.h
+++ b/cpp/generated/xtreemfs/DIR.pb.h
@@ -8,22 +8,23 @@
#include
-#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#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
#include "include/PBRPC.pb.h"
#include "include/Common.pb.h"
#include "xtreemfs/GlobalTypes.pb.h"
@@ -61,11 +62,12 @@ enum ServiceType {
SERVICE_TYPE_MIXED = 0,
SERVICE_TYPE_MRC = 1,
SERVICE_TYPE_OSD = 2,
- SERVICE_TYPE_VOLUME = 3
+ 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_VOLUME;
+const ServiceType ServiceType_MAX = SERVICE_TYPE_DIR;
const int ServiceType_ARRAYSIZE = ServiceType_MAX + 1;
const ::google::protobuf::EnumDescriptor* ServiceType_descriptor();
@@ -104,29 +106,29 @@ 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);
@@ -134,7 +136,7 @@ class AddressMapping : public ::google::protobuf::Message {
void MergeFrom(const AddressMapping& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -147,13 +149,13 @@ class AddressMapping : public ::google::protobuf::Message {
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();
@@ -163,14 +165,16 @@ class AddressMapping : public ::google::protobuf::Message {
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();
@@ -180,7 +184,9 @@ class AddressMapping : public ::google::protobuf::Message {
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();
@@ -190,14 +196,16 @@ class AddressMapping : public ::google::protobuf::Message {
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();
@@ -207,14 +215,16 @@ class AddressMapping : public ::google::protobuf::Message {
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();
@@ -224,42 +234,46 @@ class AddressMapping : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* uuid_;
- static const ::std::string _default_uuid_;
::google::protobuf::uint64 version_;
::std::string* protocol_;
- static const ::std::string _default_protocol_;
::std::string* address_;
- static const ::std::string _default_address_;
- ::google::protobuf::uint32 port_;
::std::string* match_network_;
- static const ::std::string _default_match_network_;
+ ::google::protobuf::uint32 port_;
::google::protobuf::uint32 ttl_s_;
::std::string* uri_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static AddressMapping* default_instance_;
};
@@ -269,29 +283,29 @@ 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);
@@ -299,7 +313,7 @@ class AddressMappingSet : public ::google::protobuf::Message {
void MergeFrom(const AddressMappingSet& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -312,13 +326,13 @@ class AddressMappingSet : public ::google::protobuf::Message {
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();
@@ -330,30 +344,21 @@ class AddressMappingSet : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static AddressMappingSet* default_instance_;
};
@@ -363,29 +368,29 @@ 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);
@@ -393,7 +398,7 @@ class DirService : public ::google::protobuf::Message {
void MergeFrom(const DirService& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -406,13 +411,13 @@ class DirService : public ::google::protobuf::Message {
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();
@@ -422,14 +427,16 @@ class DirService : public ::google::protobuf::Message {
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();
@@ -439,42 +446,41 @@ class DirService : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* address_;
- static const ::std::string _default_address_;
- ::google::protobuf::uint32 port_;
::std::string* protocol_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static DirService* default_instance_;
};
@@ -484,29 +490,29 @@ 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);
@@ -514,7 +520,7 @@ class ServiceDataMap : public ::google::protobuf::Message {
void MergeFrom(const ServiceDataMap& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -527,13 +533,13 @@ class ServiceDataMap : public ::google::protobuf::Message {
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();
@@ -545,30 +551,21 @@ class ServiceDataMap : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static ServiceDataMap* default_instance_;
};
@@ -578,29 +575,29 @@ 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);
@@ -608,7 +605,7 @@ class Service : public ::google::protobuf::Message {
void MergeFrom(const Service& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -621,20 +618,20 @@ class Service : public ::google::protobuf::Message {
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);
-
+ 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();
@@ -644,14 +641,16 @@ class Service : public ::google::protobuf::Message {
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();
@@ -661,51 +660,56 @@ class Service : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
- int type_;
+
::std::string* uuid_;
- static const ::std::string _default_uuid_;
::google::protobuf::uint64 version_;
::std::string* name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Service* default_instance_;
};
@@ -715,29 +719,29 @@ 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);
@@ -745,7 +749,7 @@ class ServiceSet : public ::google::protobuf::Message {
void MergeFrom(const ServiceSet& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -758,13 +762,13 @@ class ServiceSet : public ::google::protobuf::Message {
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();
@@ -776,30 +780,21 @@ class ServiceSet : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static ServiceSet* default_instance_;
};
@@ -809,29 +804,29 @@ 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);
@@ -839,7 +834,7 @@ class Configuration : public ::google::protobuf::Message {
void MergeFrom(const Configuration& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -852,13 +847,13 @@ class Configuration : public ::google::protobuf::Message {
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();
@@ -868,7 +863,9 @@ class Configuration : public ::google::protobuf::Message {
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();
@@ -880,40 +877,34 @@ class Configuration : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* uuid_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Configuration* default_instance_;
};
@@ -923,29 +914,29 @@ 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);
@@ -953,7 +944,7 @@ class addressMappingGetRequest : public ::google::protobuf::Message {
void MergeFrom(const addressMappingGetRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -966,13 +957,13 @@ class addressMappingGetRequest : public ::google::protobuf::Message {
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();
@@ -982,31 +973,25 @@ class addressMappingGetRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* uuid_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static addressMappingGetRequest* default_instance_;
};
@@ -1016,29 +1001,29 @@ 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);
@@ -1046,7 +1031,7 @@ class addressMappingGetResponse : public ::google::protobuf::Message {
void MergeFrom(const addressMappingGetResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1059,43 +1044,38 @@ class addressMappingGetResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static addressMappingGetResponse* default_instance_;
};
@@ -1105,29 +1085,29 @@ 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);
@@ -1135,7 +1115,7 @@ class addressMappingSetResponse : public ::google::protobuf::Message {
void MergeFrom(const addressMappingSetResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1148,43 +1128,36 @@ class addressMappingSetResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static addressMappingSetResponse* default_instance_;
};
@@ -1194,29 +1167,29 @@ 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);
@@ -1224,7 +1197,7 @@ class globalTimeSGetResponse : public ::google::protobuf::Message {
void MergeFrom(const globalTimeSGetResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1237,43 +1210,36 @@ class globalTimeSGetResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static globalTimeSGetResponse* default_instance_;
};
@@ -1283,29 +1249,29 @@ 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);
@@ -1313,7 +1279,7 @@ class serviceDeregisterRequest : public ::google::protobuf::Message {
void MergeFrom(const serviceDeregisterRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1326,13 +1292,13 @@ class serviceDeregisterRequest : public ::google::protobuf::Message {
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();
@@ -1342,31 +1308,25 @@ class serviceDeregisterRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* uuid_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static serviceDeregisterRequest* default_instance_;
};
@@ -1376,29 +1336,29 @@ 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);
@@ -1406,7 +1366,7 @@ class serviceGetByNameRequest : public ::google::protobuf::Message {
void MergeFrom(const serviceGetByNameRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1419,13 +1379,13 @@ class serviceGetByNameRequest : public ::google::protobuf::Message {
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();
@@ -1435,31 +1395,25 @@ class serviceGetByNameRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static serviceGetByNameRequest* default_instance_;
};
@@ -1469,29 +1423,29 @@ 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);
@@ -1499,7 +1453,7 @@ class serviceGetByUUIDRequest : public ::google::protobuf::Message {
void MergeFrom(const serviceGetByUUIDRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1512,13 +1466,13 @@ class serviceGetByUUIDRequest : public ::google::protobuf::Message {
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();
@@ -1528,31 +1482,25 @@ class serviceGetByUUIDRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static serviceGetByUUIDRequest* default_instance_;
};
@@ -1562,29 +1510,29 @@ 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);
@@ -1592,7 +1540,7 @@ class serviceGetByTypeRequest : public ::google::protobuf::Message {
void MergeFrom(const serviceGetByTypeRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1605,43 +1553,36 @@ class serviceGetByTypeRequest : public ::google::protobuf::Message {
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);
-
+ 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_;
- mutable int _cached_size_;
-
+
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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static serviceGetByTypeRequest* default_instance_;
};
@@ -1651,29 +1592,29 @@ 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);
@@ -1681,7 +1622,7 @@ class serviceRegisterRequest : public ::google::protobuf::Message {
void MergeFrom(const serviceRegisterRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1694,43 +1635,38 @@ class serviceRegisterRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static serviceRegisterRequest* default_instance_;
};
@@ -1740,29 +1676,29 @@ 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);
@@ -1770,7 +1706,7 @@ class serviceRegisterResponse : public ::google::protobuf::Message {
void MergeFrom(const serviceRegisterResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1783,43 +1719,36 @@ class serviceRegisterResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static serviceRegisterResponse* default_instance_;
};
@@ -1829,29 +1758,29 @@ 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);
@@ -1859,7 +1788,7 @@ class configurationGetRequest : public ::google::protobuf::Message {
void MergeFrom(const configurationGetRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1872,13 +1801,13 @@ class configurationGetRequest : public ::google::protobuf::Message {
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();
@@ -1888,31 +1817,25 @@ class configurationGetRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* uuid_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static configurationGetRequest* default_instance_;
};
@@ -1922,29 +1845,29 @@ 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);
@@ -1952,7 +1875,7 @@ class configurationSetResponse : public ::google::protobuf::Message {
void MergeFrom(const configurationSetResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1965,227 +1888,41 @@ class configurationSetResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static configurationSetResponse* default_instance_;
};
// ===================================================================
-class DirectoryService_Stub;
-
-class DirectoryService : public ::google::protobuf::Service {
- protected:
- // This class should be treated as an abstract interface.
- inline DirectoryService() {};
- public:
- virtual ~DirectoryService();
-
- typedef DirectoryService_Stub Stub;
-
- static const ::google::protobuf::ServiceDescriptor* descriptor();
-
- virtual void xtreemfs_address_mappings_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::addressMappingGetRequest* request,
- ::xtreemfs::pbrpc::AddressMappingSet* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_address_mappings_remove(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::addressMappingGetRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_address_mappings_set(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::AddressMappingSet* request,
- ::xtreemfs::pbrpc::addressMappingSetResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_discover_dir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::DirService* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_global_time_s_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::globalTimeSGetResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_service_deregister(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceDeregisterRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_service_get_by_name(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByNameRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_service_get_by_type(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByTypeRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_service_get_by_uuid(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByUUIDRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_service_offline(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByUUIDRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_service_register(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceRegisterRequest* request,
- ::xtreemfs::pbrpc::serviceRegisterResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_checkpoint(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_shutdown(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_configuration_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::configurationGetRequest* request,
- ::xtreemfs::pbrpc::Configuration* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_configuration_set(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Configuration* request,
- ::xtreemfs::pbrpc::configurationSetResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_vivaldi_client_update(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::VivaldiCoordinates* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
-
- // implements Service ----------------------------------------------
-
- const ::google::protobuf::ServiceDescriptor* GetDescriptor();
- void CallMethod(const ::google::protobuf::MethodDescriptor* method,
- ::google::protobuf::RpcController* controller,
- const ::google::protobuf::Message* request,
- ::google::protobuf::Message* response,
- ::google::protobuf::Closure* done);
- const ::google::protobuf::Message& GetRequestPrototype(
- const ::google::protobuf::MethodDescriptor* method) const;
- const ::google::protobuf::Message& GetResponsePrototype(
- const ::google::protobuf::MethodDescriptor* method) const;
-
- private:
- GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DirectoryService);
-};
-
-class DirectoryService_Stub : public DirectoryService {
- public:
- DirectoryService_Stub(::google::protobuf::RpcChannel* channel);
- DirectoryService_Stub(::google::protobuf::RpcChannel* channel,
- ::google::protobuf::Service::ChannelOwnership ownership);
- ~DirectoryService_Stub();
-
- inline ::google::protobuf::RpcChannel* channel() { return channel_; }
-
- // implements DirectoryService ------------------------------------------
-
- void xtreemfs_address_mappings_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::addressMappingGetRequest* request,
- ::xtreemfs::pbrpc::AddressMappingSet* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_address_mappings_remove(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::addressMappingGetRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_address_mappings_set(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::AddressMappingSet* request,
- ::xtreemfs::pbrpc::addressMappingSetResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_discover_dir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::DirService* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_global_time_s_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::globalTimeSGetResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_service_deregister(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceDeregisterRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_service_get_by_name(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByNameRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_service_get_by_type(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByTypeRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_service_get_by_uuid(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByUUIDRequest* request,
- ::xtreemfs::pbrpc::ServiceSet* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_service_offline(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceGetByUUIDRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_service_register(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::serviceRegisterRequest* request,
- ::xtreemfs::pbrpc::serviceRegisterResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_checkpoint(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_shutdown(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_configuration_get(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::configurationGetRequest* request,
- ::xtreemfs::pbrpc::Configuration* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_configuration_set(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Configuration* request,
- ::xtreemfs::pbrpc::configurationSetResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_vivaldi_client_update(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::VivaldiCoordinates* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- private:
- ::google::protobuf::RpcChannel* channel_;
- bool owns_channel_;
- GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DirectoryService_Stub);
-};
-
-
-// ===================================================================
-
// ===================================================================
@@ -2193,261 +1930,419 @@ class DirectoryService_Stub : public DirectoryService {
// required string uuid = 1;
inline bool AddressMapping::has_uuid() const {
- return _has_bit(0);
+ 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_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
- _clear_bit(0);
+ clear_has_uuid();
}
inline const ::std::string& AddressMapping::uuid() const {
return *uuid_;
}
inline void AddressMapping::set_uuid(const ::std::string& value) {
- _set_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_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_bit(1);
+ 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_bit(1);
+ clear_has_version();
}
inline ::google::protobuf::uint64 AddressMapping::version() const {
return version_;
}
inline void AddressMapping::set_version(::google::protobuf::uint64 value) {
- _set_bit(1);
+ set_has_version();
version_ = value;
}
// required string protocol = 3;
inline bool AddressMapping::has_protocol() const {
- return _has_bit(2);
+ 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_ != &_default_protocol_) {
+ if (protocol_ != &::google::protobuf::internal::kEmptyString) {
protocol_->clear();
}
- _clear_bit(2);
+ clear_has_protocol();
}
inline const ::std::string& AddressMapping::protocol() const {
return *protocol_;
}
inline void AddressMapping::set_protocol(const ::std::string& value) {
- _set_bit(2);
- if (protocol_ == &_default_protocol_) {
+ 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_bit(2);
- if (protocol_ == &_default_protocol_) {
+ 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_bit(2);
- if (protocol_ == &_default_protocol_) {
+ 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_bit(2);
- if (protocol_ == &_default_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_bit(3);
+ 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_ != &_default_address_) {
+ if (address_ != &::google::protobuf::internal::kEmptyString) {
address_->clear();
}
- _clear_bit(3);
+ clear_has_address();
}
inline const ::std::string& AddressMapping::address() const {
return *address_;
}
inline void AddressMapping::set_address(const ::std::string& value) {
- _set_bit(3);
- if (address_ == &_default_address_) {
+ 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_bit(3);
- if (address_ == &_default_address_) {
+ 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_bit(3);
- if (address_ == &_default_address_) {
+ 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_bit(3);
- if (address_ == &_default_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_bit(4);
+ 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_bit(4);
+ clear_has_port();
}
inline ::google::protobuf::uint32 AddressMapping::port() const {
return port_;
}
inline void AddressMapping::set_port(::google::protobuf::uint32 value) {
- _set_bit(4);
+ set_has_port();
port_ = value;
}
// required string match_network = 6;
inline bool AddressMapping::has_match_network() const {
- return _has_bit(5);
+ 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_ != &_default_match_network_) {
+ if (match_network_ != &::google::protobuf::internal::kEmptyString) {
match_network_->clear();
}
- _clear_bit(5);
+ 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_bit(5);
- if (match_network_ == &_default_match_network_) {
+ 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_bit(5);
- if (match_network_ == &_default_match_network_) {
+ 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_bit(5);
- if (match_network_ == &_default_match_network_) {
+ 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_bit(5);
- if (match_network_ == &_default_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_bit(6);
+ 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_bit(6);
+ 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_bit(6);
+ set_has_ttl_s();
ttl_s_ = value;
}
// required string uri = 8;
inline bool AddressMapping::has_uri() const {
- return _has_bit(7);
+ 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_ != &_default_uri_) {
+ if (uri_ != &::google::protobuf::internal::kEmptyString) {
uri_->clear();
}
- _clear_bit(7);
+ clear_has_uri();
}
inline const ::std::string& AddressMapping::uri() const {
return *uri_;
}
inline void AddressMapping::set_uri(const ::std::string& value) {
- _set_bit(7);
- if (uri_ == &_default_uri_) {
+ 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_bit(7);
- if (uri_ == &_default_uri_) {
+ 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_bit(7);
- if (uri_ == &_default_uri_) {
+ 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_bit(7);
- if (uri_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -2484,117 +2379,185 @@ AddressMappingSet::mutable_mappings() {
// required string address = 1;
inline bool DirService::has_address() const {
- return _has_bit(0);
+ 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_ != &_default_address_) {
+ if (address_ != &::google::protobuf::internal::kEmptyString) {
address_->clear();
}
- _clear_bit(0);
+ clear_has_address();
}
inline const ::std::string& DirService::address() const {
return *address_;
}
inline void DirService::set_address(const ::std::string& value) {
- _set_bit(0);
- if (address_ == &_default_address_) {
+ 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_bit(0);
- if (address_ == &_default_address_) {
+ 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_bit(0);
- if (address_ == &_default_address_) {
+ 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_bit(0);
- if (address_ == &_default_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_bit(1);
+ 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_bit(1);
+ clear_has_port();
}
inline ::google::protobuf::uint32 DirService::port() const {
return port_;
}
inline void DirService::set_port(::google::protobuf::uint32 value) {
- _set_bit(1);
+ set_has_port();
port_ = value;
}
// required string protocol = 3;
inline bool DirService::has_protocol() const {
- return _has_bit(2);
+ 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_ != &_default_protocol_) {
+ if (protocol_ != &::google::protobuf::internal::kEmptyString) {
protocol_->clear();
}
- _clear_bit(2);
+ clear_has_protocol();
}
inline const ::std::string& DirService::protocol() const {
return *protocol_;
}
inline void DirService::set_protocol(const ::std::string& value) {
- _set_bit(2);
- if (protocol_ == &_default_protocol_) {
+ 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_bit(2);
- if (protocol_ == &_default_protocol_) {
+ 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_bit(2);
- if (protocol_ == &_default_protocol_) {
+ 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_bit(2);
- if (protocol_ == &_default_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_bit(3);
+ 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_bit(3);
+ 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_bit(3);
+ set_has_interface_version();
interface_version_ = value;
}
@@ -2633,153 +2596,248 @@ ServiceDataMap::mutable_data() {
// required .xtreemfs.pbrpc.ServiceType type = 1;
inline bool Service::has_type() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_type();
}
-inline xtreemfs::pbrpc::ServiceType Service::type() const {
- return static_cast< xtreemfs::pbrpc::ServiceType >(type_);
+inline ::xtreemfs::pbrpc::ServiceType Service::type() const {
+ return static_cast< ::xtreemfs::pbrpc::ServiceType >(type_);
}
-inline void Service::set_type(xtreemfs::pbrpc::ServiceType value) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::ServiceType_IsValid(value));
- _set_bit(0);
+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_bit(1);
+ 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_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
- _clear_bit(1);
+ clear_has_uuid();
}
inline const ::std::string& Service::uuid() const {
return *uuid_;
}
inline void Service::set_uuid(const ::std::string& value) {
- _set_bit(1);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(1);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(1);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(1);
- if (uuid_ == &_default_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_bit(2);
+ 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_bit(2);
+ clear_has_version();
}
inline ::google::protobuf::uint64 Service::version() const {
return version_;
}
inline void Service::set_version(::google::protobuf::uint64 value) {
- _set_bit(2);
+ set_has_version();
version_ = value;
}
// required string name = 4;
inline bool Service::has_name() const {
- return _has_bit(3);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(3);
+ clear_has_name();
}
inline const ::std::string& Service::name() const {
return *name_;
}
inline void Service::set_name(const ::std::string& value) {
- _set_bit(3);
- if (name_ == &_default_name_) {
+ 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_bit(3);
- if (name_ == &_default_name_) {
+ 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_bit(3);
- if (name_ == &_default_name_) {
+ 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_bit(3);
- if (name_ == &_default_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_bit(4);
+ 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_bit(4);
+ 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_bit(4);
+ set_has_last_updated_s();
last_updated_s_ = value;
}
// required .xtreemfs.pbrpc.ServiceDataMap data = 6;
inline bool Service::has_data() const {
- return _has_bit(5);
+ 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_bit(5);
+ 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_bit(5);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -2816,45 +2874,73 @@ ServiceSet::mutable_services() {
// required string uuid = 1;
inline bool Configuration::has_uuid() const {
- return _has_bit(0);
+ 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_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
- _clear_bit(0);
+ clear_has_uuid();
}
inline const ::std::string& Configuration::uuid() const {
return *uuid_;
}
inline void Configuration::set_uuid(const ::std::string& value) {
- _set_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_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 {
@@ -2883,17 +2969,23 @@ Configuration::mutable_parameter() {
// required fixed64 version = 3;
inline bool Configuration::has_version() const {
- return _has_bit(2);
+ 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_bit(2);
+ clear_has_version();
}
inline ::google::protobuf::uint64 Configuration::version() const {
return version_;
}
inline void Configuration::set_version(::google::protobuf::uint64 value) {
- _set_bit(2);
+ set_has_version();
version_ = value;
}
@@ -2903,45 +2995,73 @@ inline void Configuration::set_version(::google::protobuf::uint64 value) {
// required string uuid = 1;
inline bool addressMappingGetRequest::has_uuid() const {
- return _has_bit(0);
+ 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_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
- _clear_bit(0);
+ clear_has_uuid();
}
inline const ::std::string& addressMappingGetRequest::uuid() const {
return *uuid_;
}
inline void addressMappingGetRequest::set_uuid(const ::std::string& value) {
- _set_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -2949,20 +3069,41 @@ inline ::std::string* addressMappingGetRequest::mutable_uuid() {
// optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
inline bool addressMappingGetResponse::has_result() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -2970,17 +3111,23 @@ inline ::xtreemfs::pbrpc::AddressMappingSet* addressMappingGetResponse::mutable_
// optional fixed64 new_version = 1;
inline bool addressMappingSetResponse::has_new_version() const {
- return _has_bit(0);
+ 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_bit(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_bit(0);
+ set_has_new_version();
new_version_ = value;
}
@@ -2990,17 +3137,23 @@ inline void addressMappingSetResponse::set_new_version(::google::protobuf::uint6
// required fixed64 time_in_seconds = 1;
inline bool globalTimeSGetResponse::has_time_in_seconds() const {
- return _has_bit(0);
+ 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_bit(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_bit(0);
+ set_has_time_in_seconds();
time_in_seconds_ = value;
}
@@ -3010,45 +3163,73 @@ inline void globalTimeSGetResponse::set_time_in_seconds(::google::protobuf::uint
// required string uuid = 1;
inline bool serviceDeregisterRequest::has_uuid() const {
- return _has_bit(0);
+ 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_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
- _clear_bit(0);
+ clear_has_uuid();
}
inline const ::std::string& serviceDeregisterRequest::uuid() const {
return *uuid_;
}
inline void serviceDeregisterRequest::set_uuid(const ::std::string& value) {
- _set_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -3056,45 +3237,73 @@ inline ::std::string* serviceDeregisterRequest::mutable_uuid() {
// required string name = 1;
inline bool serviceGetByNameRequest::has_name() const {
- return _has_bit(0);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(0);
+ clear_has_name();
}
inline const ::std::string& serviceGetByNameRequest::name() const {
return *name_;
}
inline void serviceGetByNameRequest::set_name(const ::std::string& value) {
- _set_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -3102,45 +3311,73 @@ inline ::std::string* serviceGetByNameRequest::mutable_name() {
// required string name = 1;
inline bool serviceGetByUUIDRequest::has_name() const {
- return _has_bit(0);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(0);
+ clear_has_name();
}
inline const ::std::string& serviceGetByUUIDRequest::name() const {
return *name_;
}
inline void serviceGetByUUIDRequest::set_name(const ::std::string& value) {
- _set_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -3148,18 +3385,24 @@ inline ::std::string* serviceGetByUUIDRequest::mutable_name() {
// required .xtreemfs.pbrpc.ServiceType type = 1;
inline bool serviceGetByTypeRequest::has_type() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_type();
}
-inline xtreemfs::pbrpc::ServiceType serviceGetByTypeRequest::type() const {
- return static_cast< xtreemfs::pbrpc::ServiceType >(type_);
+inline ::xtreemfs::pbrpc::ServiceType serviceGetByTypeRequest::type() const {
+ return static_cast< ::xtreemfs::pbrpc::ServiceType >(type_);
}
-inline void serviceGetByTypeRequest::set_type(xtreemfs::pbrpc::ServiceType value) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::ServiceType_IsValid(value));
- _set_bit(0);
+inline void serviceGetByTypeRequest::set_type(::xtreemfs::pbrpc::ServiceType value) {
+ assert(::xtreemfs::pbrpc::ServiceType_IsValid(value));
+ set_has_type();
type_ = value;
}
@@ -3169,20 +3412,41 @@ inline void serviceGetByTypeRequest::set_type(xtreemfs::pbrpc::ServiceType value
// required .xtreemfs.pbrpc.Service service = 1;
inline bool serviceRegisterRequest::has_service() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -3190,17 +3454,23 @@ inline ::xtreemfs::pbrpc::Service* serviceRegisterRequest::mutable_service() {
// required fixed64 new_version = 1;
inline bool serviceRegisterResponse::has_new_version() const {
- return _has_bit(0);
+ 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_bit(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_bit(0);
+ set_has_new_version();
new_version_ = value;
}
@@ -3210,45 +3480,73 @@ inline void serviceRegisterResponse::set_new_version(::google::protobuf::uint64
// required string uuid = 1;
inline bool configurationGetRequest::has_uuid() const {
- return _has_bit(0);
+ 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_ != &_default_uuid_) {
+ if (uuid_ != &::google::protobuf::internal::kEmptyString) {
uuid_->clear();
}
- _clear_bit(0);
+ clear_has_uuid();
}
inline const ::std::string& configurationGetRequest::uuid() const {
return *uuid_;
}
inline void configurationGetRequest::set_uuid(const ::std::string& value) {
- _set_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_uuid_) {
+ 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_bit(0);
- if (uuid_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -3256,17 +3554,23 @@ inline ::std::string* configurationGetRequest::mutable_uuid() {
// optional fixed64 new_version = 1;
inline bool configurationSetResponse::has_new_version() const {
- return _has_bit(0);
+ 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_bit(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_bit(0);
+ set_has_new_version();
new_version_ = value;
}
@@ -3281,12 +3585,12 @@ namespace google {
namespace protobuf {
template <>
-inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::ServiceType>() {
- return xtreemfs::pbrpc::ServiceType_descriptor();
+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();
+inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::ServiceStatus>() {
+ return ::xtreemfs::pbrpc::ServiceStatus_descriptor();
}
} // namespace google
diff --git a/cpp/generated/xtreemfs/DIRServiceClient.h b/cpp/generated/xtreemfs/DIRServiceClient.h
index ae62f5ff461bb725d2a8499a1f382c2e774017cb..9593e46ad9ae9bbea2d31e8082cd80d483cd852c 100644
--- a/cpp/generated/xtreemfs/DIRServiceClient.h
+++ b/cpp/generated/xtreemfs/DIRServiceClient.h
@@ -1,4 +1,4 @@
-//automatically generated from DIR.proto at Thu Mar 21 17:09:46 CET 2013
+//automatically generated from DIR.proto at Mon Nov 11 11:46:59 CET 2013
//(c) 2013. See LICENSE file for details.
#ifndef DIRSERVICECLIENT_H
@@ -9,10 +9,9 @@
#include "rpc/client.h"
#include "rpc/sync_callback.h"
#include "rpc/callback_interface.h"
-#include "xtreemfs/OSD.pb.h"
#include "include/Common.pb.h"
-#include "xtreemfs/DIR.pb.h"
#include "xtreemfs/GlobalTypes.pb.h"
+#include "xtreemfs/DIR.pb.h"
namespace xtreemfs {
diff --git a/cpp/generated/xtreemfs/DIRServiceConstants.h b/cpp/generated/xtreemfs/DIRServiceConstants.h
index 97bd3afc77e02ad5ee3833eabfa7e8628c5dd841..010132f1eb7b45645b995a401a5980fca30c704a 100644
--- a/cpp/generated/xtreemfs/DIRServiceConstants.h
+++ b/cpp/generated/xtreemfs/DIRServiceConstants.h
@@ -1,4 +1,4 @@
-//automatically generated from DIR.proto at Thu Mar 21 17:09:46 CET 2013
+//automatically generated from DIR.proto at Mon Nov 11 11:46:59 CET 2013
//(c) 2013. See LICENSE file for details.
#ifndef DIRSERVICECONSTANTS_H_
diff --git a/cpp/generated/xtreemfs/GlobalTypes.pb.cc b/cpp/generated/xtreemfs/GlobalTypes.pb.cc
index 0fad08f99c59ae29662fd9bb0eb71a3b7e331ba0..43eb62aea259872b5e9f5c967bf9f6bfa4b03b41 100644
--- a/cpp/generated/xtreemfs/GlobalTypes.pb.cc
+++ b/cpp/generated/xtreemfs/GlobalTypes.pb.cc
@@ -1,11 +1,17 @@
// 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)
@@ -444,7 +450,6 @@ struct 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_;
@@ -661,7 +666,8 @@ const ::google::protobuf::Descriptor* NewFileSize::descriptor() {
}
const NewFileSize& NewFileSize::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
NewFileSize* NewFileSize::default_instance_ = NULL;
@@ -692,14 +698,14 @@ bool NewFileSize::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &size_in_bytes_)));
- _set_bit(0);
+ 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) ==
@@ -708,14 +714,14 @@ bool NewFileSize::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &truncate_epoch_)));
- _set_bit(1);
+ set_has_truncate_epoch();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -735,15 +741,15 @@ bool NewFileSize::MergePartialFromCodedStream(
void NewFileSize::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed64 size_in_bytes = 1;
- if (_has_bit(0)) {
+ if (has_size_in_bytes()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->size_in_bytes(), output);
}
-
+
// required fixed32 truncate_epoch = 2;
- if (_has_bit(1)) {
+ 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);
@@ -753,15 +759,15 @@ void NewFileSize::SerializeWithCachedSizes(
::google::protobuf::uint8* NewFileSize::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed64 size_in_bytes = 1;
- if (_has_bit(0)) {
+ if (has_size_in_bytes()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->size_in_bytes(), target);
}
-
+
// required fixed32 truncate_epoch = 2;
- if (_has_bit(1)) {
+ 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);
@@ -771,18 +777,18 @@ void NewFileSize::SerializeWithCachedSizes(
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 +=
@@ -810,10 +816,10 @@ void NewFileSize::MergeFrom(const ::google::protobuf::Message& from) {
void NewFileSize::MergeFrom(const NewFileSize& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_size_in_bytes()) {
set_size_in_bytes(from.size_in_bytes());
}
- if (from._has_bit(1)) {
+ if (from.has_truncate_epoch()) {
set_truncate_epoch(from.truncate_epoch());
}
}
@@ -834,7 +840,7 @@ void NewFileSize::CopyFrom(const NewFileSize& from) {
bool NewFileSize::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
@@ -907,7 +913,8 @@ const ::google::protobuf::Descriptor* StripingPolicy::descriptor() {
}
const StripingPolicy& StripingPolicy::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
StripingPolicy* StripingPolicy::default_instance_ = NULL;
@@ -940,8 +947,8 @@ bool StripingPolicy::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::StripingPolicyType_IsValid(value)) {
+ set_type(static_cast< ::xtreemfs::pbrpc::StripingPolicyType >(value));
} else {
mutable_unknown_fields()->AddVarint(1, value);
}
@@ -951,7 +958,7 @@ bool StripingPolicy::MergePartialFromCodedStream(
if (input->ExpectTag(21)) goto parse_stripe_size;
break;
}
-
+
// required fixed32 stripe_size = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -960,14 +967,14 @@ bool StripingPolicy::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &stripe_size_)));
- _set_bit(1);
+ 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) ==
@@ -976,14 +983,14 @@ bool StripingPolicy::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &width_)));
- _set_bit(2);
+ set_has_width();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1003,21 +1010,21 @@ bool StripingPolicy::MergePartialFromCodedStream(
void StripingPolicy::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.StripingPolicyType type = 1;
- if (_has_bit(0)) {
+ if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
1, this->type(), output);
}
-
+
// required fixed32 stripe_size = 2;
- if (_has_bit(1)) {
+ if (has_stripe_size()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->stripe_size(), output);
}
-
+
// required fixed32 width = 3;
- if (_has_bit(2)) {
+ if (has_width()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->width(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -1027,21 +1034,21 @@ void StripingPolicy::SerializeWithCachedSizes(
::google::protobuf::uint8* StripingPolicy::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.StripingPolicyType type = 1;
- if (_has_bit(0)) {
+ if (has_type()) {
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1, this->type(), target);
}
-
+
// required fixed32 stripe_size = 2;
- if (_has_bit(1)) {
+ if (has_stripe_size()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->stripe_size(), target);
}
-
+
// required fixed32 width = 3;
- if (_has_bit(2)) {
+ if (has_width()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->width(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -1051,24 +1058,24 @@ void StripingPolicy::SerializeWithCachedSizes(
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;
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -1096,13 +1103,13 @@ void StripingPolicy::MergeFrom(const ::google::protobuf::Message& from) {
void StripingPolicy::MergeFrom(const StripingPolicy& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_type()) {
set_type(from.type());
}
- if (from._has_bit(1)) {
+ if (from.has_stripe_size()) {
set_stripe_size(from.stripe_size());
}
- if (from._has_bit(2)) {
+ if (from.has_width()) {
set_width(from.width());
}
}
@@ -1123,7 +1130,7 @@ void StripingPolicy::CopyFrom(const StripingPolicy& from) {
bool StripingPolicy::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -1198,7 +1205,8 @@ const ::google::protobuf::Descriptor* Replica::descriptor() {
}
const Replica& Replica::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
Replica* Replica::default_instance_ = NULL;
@@ -1210,7 +1218,7 @@ Replica* Replica::New() const {
void Replica::Clear() {
if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
replication_flags_ = 0u;
- if (_has_bit(2)) {
+ if (has_striping_policy()) {
if (striping_policy_ != NULL) striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear();
}
}
@@ -1233,7 +1241,8 @@ bool Replica::MergePartialFromCodedStream(
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->add_osd_uuids()));
::google::protobuf::internal::WireFormat::VerifyUTF8String(
- this->osd_uuids(0).data(), this->osd_uuids(0).length(),
+ 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;
@@ -1242,7 +1251,7 @@ bool Replica::MergePartialFromCodedStream(
if (input->ExpectTag(21)) goto parse_replication_flags;
break;
}
-
+
// required fixed32 replication_flags = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1251,14 +1260,14 @@ bool Replica::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &replication_flags_)));
- _set_bit(1);
+ 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) ==
@@ -1272,7 +1281,7 @@ bool Replica::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1299,18 +1308,18 @@ void Replica::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteString(
1, this->osd_uuids(i), output);
}
-
+
// required fixed32 replication_flags = 2;
- if (_has_bit(1)) {
+ if (has_replication_flags()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->replication_flags(), output);
}
-
+
// required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3;
- if (_has_bit(2)) {
+ 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);
@@ -1327,19 +1336,19 @@ void Replica::SerializeWithCachedSizes(
target = ::google::protobuf::internal::WireFormatLite::
WriteStringToArray(1, this->osd_uuids(i), target);
}
-
+
// required fixed32 replication_flags = 2;
- if (_has_bit(1)) {
+ if (has_replication_flags()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->replication_flags(), target);
}
-
+
// required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3;
- if (_has_bit(2)) {
+ 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);
@@ -1349,20 +1358,20 @@ void Replica::SerializeWithCachedSizes(
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();
@@ -1370,7 +1379,7 @@ int Replica::ByteSize() const {
total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
this->osd_uuids(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -1398,10 +1407,10 @@ 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_bit(1)) {
+ if (from.has_replication_flags()) {
set_replication_flags(from.replication_flags());
}
- if (from._has_bit(2)) {
+ if (from.has_striping_policy()) {
mutable_striping_policy()->::xtreemfs::pbrpc::StripingPolicy::MergeFrom(from.striping_policy());
}
}
@@ -1422,7 +1431,7 @@ void Replica::CopyFrom(const Replica& from) {
bool Replica::IsInitialized() const {
if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
-
+
if (has_striping_policy()) {
if (!this->striping_policy().IsInitialized()) return false;
}
@@ -1494,7 +1503,8 @@ const ::google::protobuf::Descriptor* Replicas::descriptor() {
}
const Replicas& Replicas::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
Replicas* Replicas::default_instance_ = NULL;
@@ -1529,7 +1539,7 @@ bool Replicas::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1553,7 +1563,7 @@ void Replicas::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->replicas(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -1568,7 +1578,7 @@ void Replicas::SerializeWithCachedSizes(
WriteMessageNoVirtualToArray(
1, this->replicas(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -1578,7 +1588,7 @@ void Replicas::SerializeWithCachedSizes(
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++) {
@@ -1586,7 +1596,7 @@ int Replicas::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->replicas(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -1629,7 +1639,7 @@ void Replicas::CopyFrom(const Replicas& from) {
}
bool Replicas::IsInitialized() const {
-
+
for (int i = 0; i < replicas_size(); i++) {
if (!this->replicas(i).IsInitialized()) return false;
}
@@ -1656,9 +1666,6 @@ void Replicas::Swap(Replicas* other) {
// ===================================================================
-const ::std::string XCap::_default_client_identity_;
-const ::std::string XCap::_default_file_id_;
-const ::std::string XCap::_default_server_signature_;
#ifndef _MSC_VER
const int XCap::kAccessModeFieldNumber;
const int XCap::kClientIdentityFieldNumber;
@@ -1689,12 +1696,12 @@ XCap::XCap(const XCap& from)
void XCap::SharedCtor() {
_cached_size_ = 0;
access_mode_ = 0u;
- client_identity_ = const_cast< ::std::string*>(&_default_client_identity_);
+ 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*>(&_default_file_id_);
+ file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
replicate_on_close_ = false;
- server_signature_ = const_cast< ::std::string*>(&_default_server_signature_);
+ server_signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
truncate_epoch_ = 0u;
snap_config_ = 0;
snap_timestamp_ = GOOGLE_ULONGLONG(0);
@@ -1706,13 +1713,13 @@ XCap::~XCap() {
}
void XCap::SharedDtor() {
- if (client_identity_ != &_default_client_identity_) {
+ if (client_identity_ != &::google::protobuf::internal::kEmptyString) {
delete client_identity_;
}
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
- if (server_signature_ != &_default_server_signature_) {
+ if (server_signature_ != &::google::protobuf::internal::kEmptyString) {
delete server_signature_;
}
if (this != default_instance_) {
@@ -1730,7 +1737,8 @@ const ::google::protobuf::Descriptor* XCap::descriptor() {
}
const XCap& XCap::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
XCap* XCap::default_instance_ = NULL;
@@ -1742,21 +1750,21 @@ XCap* XCap::New() const {
void XCap::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
access_mode_ = 0u;
- if (_has_bit(1)) {
- if (client_identity_ != &_default_client_identity_) {
+ 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_bit(4)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
replicate_on_close_ = false;
- if (_has_bit(6)) {
- if (server_signature_ != &_default_server_signature_) {
+ if (has_server_signature()) {
+ if (server_signature_ != &::google::protobuf::internal::kEmptyString) {
server_signature_->clear();
}
}
@@ -1783,14 +1791,14 @@ bool XCap::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &access_mode_)));
- _set_bit(0);
+ 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) ==
@@ -1807,7 +1815,7 @@ bool XCap::MergePartialFromCodedStream(
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) ==
@@ -1816,14 +1824,14 @@ bool XCap::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &expire_time_s_)));
- _set_bit(2);
+ 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) ==
@@ -1832,14 +1840,14 @@ bool XCap::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &expire_timeout_s_)));
- _set_bit(3);
+ 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) ==
@@ -1856,7 +1864,7 @@ bool XCap::MergePartialFromCodedStream(
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) ==
@@ -1865,14 +1873,14 @@ bool XCap::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &replicate_on_close_)));
- _set_bit(5);
+ 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) ==
@@ -1889,7 +1897,7 @@ bool XCap::MergePartialFromCodedStream(
if (input->ExpectTag(69)) goto parse_truncate_epoch;
break;
}
-
+
// required fixed32 truncate_epoch = 8;
case 8: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1898,14 +1906,14 @@ bool XCap::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &truncate_epoch_)));
- _set_bit(7);
+ 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) ==
@@ -1915,8 +1923,8 @@ bool XCap::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::SnapConfig_IsValid(value)) {
+ set_snap_config(static_cast< ::xtreemfs::pbrpc::SnapConfig >(value));
} else {
mutable_unknown_fields()->AddVarint(9, value);
}
@@ -1926,7 +1934,7 @@ bool XCap::MergePartialFromCodedStream(
if (input->ExpectTag(81)) goto parse_snap_timestamp;
break;
}
-
+
// required fixed64 snap_timestamp = 10;
case 10: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1935,14 +1943,14 @@ bool XCap::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &snap_timestamp_)));
- _set_bit(9);
+ set_has_snap_timestamp();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1962,68 +1970,68 @@ bool XCap::MergePartialFromCodedStream(
void XCap::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed32 access_mode = 1;
- if (_has_bit(0)) {
+ if (has_access_mode()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->access_mode(), output);
}
-
+
// required string client_identity = 2;
- if (_has_bit(1)) {
+ 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_bit(2)) {
+ if (has_expire_time_s()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->expire_time_s(), output);
}
-
+
// required fixed32 expire_timeout_s = 4;
- if (_has_bit(3)) {
+ if (has_expire_timeout_s()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->expire_timeout_s(), output);
}
-
+
// required string file_id = 5;
- if (_has_bit(4)) {
+ 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_bit(5)) {
+ if (has_replicate_on_close()) {
::google::protobuf::internal::WireFormatLite::WriteBool(6, this->replicate_on_close(), output);
}
-
+
// required string server_signature = 7;
- if (_has_bit(6)) {
+ 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_bit(7)) {
+ if (has_truncate_epoch()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(8, this->truncate_epoch(), output);
}
-
+
// required .xtreemfs.pbrpc.SnapConfig snap_config = 9;
- if (_has_bit(8)) {
+ if (has_snap_config()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
9, this->snap_config(), output);
}
-
+
// required fixed64 snap_timestamp = 10;
- if (_has_bit(9)) {
+ 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);
@@ -2033,12 +2041,12 @@ void XCap::SerializeWithCachedSizes(
::google::protobuf::uint8* XCap::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed32 access_mode = 1;
- if (_has_bit(0)) {
+ if (has_access_mode()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->access_mode(), target);
}
-
+
// required string client_identity = 2;
- if (_has_bit(1)) {
+ if (has_client_identity()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->client_identity().data(), this->client_identity().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2046,19 +2054,19 @@ void XCap::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->client_identity(), target);
}
-
+
// required fixed64 expire_time_s = 3;
- if (_has_bit(2)) {
+ 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_bit(3)) {
+ if (has_expire_timeout_s()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->expire_timeout_s(), target);
}
-
+
// required string file_id = 5;
- if (_has_bit(4)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2066,14 +2074,14 @@ void XCap::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
5, this->file_id(), target);
}
-
+
// required bool replicate_on_close = 6;
- if (_has_bit(5)) {
+ if (has_replicate_on_close()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->replicate_on_close(), target);
}
-
+
// required string server_signature = 7;
- if (_has_bit(6)) {
+ if (has_server_signature()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->server_signature().data(), this->server_signature().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2081,23 +2089,23 @@ void XCap::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
7, this->server_signature(), target);
}
-
+
// required fixed32 truncate_epoch = 8;
- if (_has_bit(7)) {
+ if (has_truncate_epoch()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(8, this->truncate_epoch(), target);
}
-
+
// required .xtreemfs.pbrpc.SnapConfig snap_config = 9;
- if (_has_bit(8)) {
+ if (has_snap_config()) {
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
9, this->snap_config(), target);
}
-
+
// required fixed64 snap_timestamp = 10;
- if (_has_bit(9)) {
+ 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);
@@ -2107,54 +2115,54 @@ void XCap::SerializeWithCachedSizes(
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;
@@ -2162,12 +2170,12 @@ int XCap::ByteSize() const {
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 +=
@@ -2195,36 +2203,36 @@ void XCap::MergeFrom(const ::google::protobuf::Message& from) {
void XCap::MergeFrom(const XCap& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_access_mode()) {
set_access_mode(from.access_mode());
}
- if (from._has_bit(1)) {
+ if (from.has_client_identity()) {
set_client_identity(from.client_identity());
}
- if (from._has_bit(2)) {
+ if (from.has_expire_time_s()) {
set_expire_time_s(from.expire_time_s());
}
- if (from._has_bit(3)) {
+ if (from.has_expire_timeout_s()) {
set_expire_timeout_s(from.expire_timeout_s());
}
- if (from._has_bit(4)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
- if (from._has_bit(5)) {
+ if (from.has_replicate_on_close()) {
set_replicate_on_close(from.replicate_on_close());
}
- if (from._has_bit(6)) {
+ if (from.has_server_signature()) {
set_server_signature(from.server_signature());
}
- if (from._has_bit(7)) {
+ if (from.has_truncate_epoch()) {
set_truncate_epoch(from.truncate_epoch());
}
}
if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
- if (from._has_bit(8)) {
+ if (from.has_snap_config()) {
set_snap_config(from.snap_config());
}
- if (from._has_bit(9)) {
+ if (from.has_snap_timestamp()) {
set_snap_timestamp(from.snap_timestamp());
}
}
@@ -2245,7 +2253,7 @@ void XCap::CopyFrom(const XCap& from) {
bool XCap::IsInitialized() const {
if ((_has_bits_[0] & 0x000003ff) != 0x000003ff) return false;
-
+
return true;
}
@@ -2278,7 +2286,6 @@ void XCap::Swap(XCap* other) {
// ===================================================================
-const ::std::string XLocSet::_default_replica_update_policy_;
#ifndef _MSC_VER
const int XLocSet::kReadOnlyFileSizeFieldNumber;
const int XLocSet::kReplicasFieldNumber;
@@ -2303,7 +2310,7 @@ XLocSet::XLocSet(const XLocSet& from)
void XLocSet::SharedCtor() {
_cached_size_ = 0;
read_only_file_size_ = GOOGLE_ULONGLONG(0);
- replica_update_policy_ = const_cast< ::std::string*>(&_default_replica_update_policy_);
+ replica_update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
version_ = 0u;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -2313,7 +2320,7 @@ XLocSet::~XLocSet() {
}
void XLocSet::SharedDtor() {
- if (replica_update_policy_ != &_default_replica_update_policy_) {
+ if (replica_update_policy_ != &::google::protobuf::internal::kEmptyString) {
delete replica_update_policy_;
}
if (this != default_instance_) {
@@ -2331,7 +2338,8 @@ const ::google::protobuf::Descriptor* XLocSet::descriptor() {
}
const XLocSet& XLocSet::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
XLocSet* XLocSet::default_instance_ = NULL;
@@ -2343,8 +2351,8 @@ XLocSet* XLocSet::New() const {
void XLocSet::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
read_only_file_size_ = GOOGLE_ULONGLONG(0);
- if (_has_bit(2)) {
- if (replica_update_policy_ != &_default_replica_update_policy_) {
+ if (has_replica_update_policy()) {
+ if (replica_update_policy_ != &::google::protobuf::internal::kEmptyString) {
replica_update_policy_->clear();
}
}
@@ -2368,14 +2376,14 @@ bool XLocSet::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &read_only_file_size_)));
- _set_bit(0);
+ 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) ==
@@ -2390,7 +2398,7 @@ bool XLocSet::MergePartialFromCodedStream(
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) ==
@@ -2407,7 +2415,7 @@ bool XLocSet::MergePartialFromCodedStream(
if (input->ExpectTag(37)) goto parse_version;
break;
}
-
+
// required fixed32 version = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2416,14 +2424,14 @@ bool XLocSet::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &version_)));
- _set_bit(3);
+ set_has_version();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2443,30 +2451,30 @@ bool XLocSet::MergePartialFromCodedStream(
void XLocSet::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed64 read_only_file_size = 1;
- if (_has_bit(0)) {
+ 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_bit(2)) {
+ 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_bit(3)) {
+ if (has_version()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->version(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -2476,19 +2484,19 @@ void XLocSet::SerializeWithCachedSizes(
::google::protobuf::uint8* XLocSet::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed64 read_only_file_size = 1;
- if (_has_bit(0)) {
+ 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_bit(2)) {
+ 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);
@@ -2496,12 +2504,12 @@ void XLocSet::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->replica_update_policy(), target);
}
-
+
// required fixed32 version = 4;
- if (_has_bit(3)) {
+ 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);
@@ -2511,25 +2519,25 @@ void XLocSet::SerializeWithCachedSizes(
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();
@@ -2538,7 +2546,7 @@ int XLocSet::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->replicas(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2566,13 +2574,13 @@ 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_bit(0)) {
+ if (from.has_read_only_file_size()) {
set_read_only_file_size(from.read_only_file_size());
}
- if (from._has_bit(2)) {
+ if (from.has_replica_update_policy()) {
set_replica_update_policy(from.replica_update_policy());
}
- if (from._has_bit(3)) {
+ if (from.has_version()) {
set_version(from.version());
}
}
@@ -2593,7 +2601,7 @@ void XLocSet::CopyFrom(const XLocSet& 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;
}
@@ -2673,7 +2681,8 @@ const ::google::protobuf::Descriptor* FileCredentials::descriptor() {
}
const FileCredentials& FileCredentials::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
FileCredentials* FileCredentials::default_instance_ = NULL;
@@ -2684,10 +2693,10 @@ FileCredentials* FileCredentials::New() const {
void FileCredentials::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_xcap()) {
if (xcap_ != NULL) xcap_->::xtreemfs::pbrpc::XCap::Clear();
}
- if (_has_bit(1)) {
+ if (has_xlocs()) {
if (xlocs_ != NULL) xlocs_->::xtreemfs::pbrpc::XLocSet::Clear();
}
}
@@ -2713,7 +2722,7 @@ bool FileCredentials::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_xlocs;
break;
}
-
+
// required .xtreemfs.pbrpc.XLocSet xlocs = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2727,7 +2736,7 @@ bool FileCredentials::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2747,17 +2756,17 @@ bool FileCredentials::MergePartialFromCodedStream(
void FileCredentials::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.XCap xcap = 1;
- if (_has_bit(0)) {
+ if (has_xcap()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->xcap(), output);
}
-
+
// required .xtreemfs.pbrpc.XLocSet xlocs = 2;
- if (_has_bit(1)) {
+ if (has_xlocs()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->xlocs(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -2767,19 +2776,19 @@ void FileCredentials::SerializeWithCachedSizes(
::google::protobuf::uint8* FileCredentials::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.XCap xcap = 1;
- if (_has_bit(0)) {
+ if (has_xcap()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->xcap(), target);
}
-
+
// required .xtreemfs.pbrpc.XLocSet xlocs = 2;
- if (_has_bit(1)) {
+ 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);
@@ -2789,7 +2798,7 @@ void FileCredentials::SerializeWithCachedSizes(
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()) {
@@ -2797,14 +2806,14 @@ int FileCredentials::ByteSize() const {
::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 +=
@@ -2832,10 +2841,10 @@ void FileCredentials::MergeFrom(const ::google::protobuf::Message& from) {
void FileCredentials::MergeFrom(const FileCredentials& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_xcap()) {
mutable_xcap()->::xtreemfs::pbrpc::XCap::MergeFrom(from.xcap());
}
- if (from._has_bit(1)) {
+ if (from.has_xlocs()) {
mutable_xlocs()->::xtreemfs::pbrpc::XLocSet::MergeFrom(from.xlocs());
}
}
@@ -2856,7 +2865,7 @@ void FileCredentials::CopyFrom(const FileCredentials& from) {
bool FileCredentials::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
if (has_xcap()) {
if (!this->xcap().IsInitialized()) return false;
}
@@ -2933,7 +2942,8 @@ const ::google::protobuf::Descriptor* FileCredentialsSet::descriptor() {
}
const FileCredentialsSet& FileCredentialsSet::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
FileCredentialsSet* FileCredentialsSet::default_instance_ = NULL;
@@ -2944,7 +2954,7 @@ FileCredentialsSet* FileCredentialsSet::New() const {
void FileCredentialsSet::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_file_credentials()) {
if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
}
}
@@ -2970,7 +2980,7 @@ bool FileCredentialsSet::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2990,11 +3000,11 @@ bool FileCredentialsSet::MergePartialFromCodedStream(
void FileCredentialsSet::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3004,12 +3014,12 @@ void FileCredentialsSet::SerializeWithCachedSizes(
::google::protobuf::uint8* FileCredentialsSet::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
- if (_has_bit(0)) {
+ 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);
@@ -3019,7 +3029,7 @@ void FileCredentialsSet::SerializeWithCachedSizes(
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()) {
@@ -3027,7 +3037,7 @@ int FileCredentialsSet::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->file_credentials());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -3055,7 +3065,7 @@ void FileCredentialsSet::MergeFrom(const ::google::protobuf::Message& from) {
void FileCredentialsSet::MergeFrom(const FileCredentialsSet& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_file_credentials()) {
mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
}
}
@@ -3075,7 +3085,7 @@ void FileCredentialsSet::CopyFrom(const FileCredentialsSet& from) {
}
bool FileCredentialsSet::IsInitialized() const {
-
+
if (has_file_credentials()) {
if (!this->file_credentials().IsInitialized()) return false;
}
@@ -3150,7 +3160,8 @@ const ::google::protobuf::Descriptor* VivaldiCoordinates::descriptor() {
}
const VivaldiCoordinates& VivaldiCoordinates::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
VivaldiCoordinates* VivaldiCoordinates::default_instance_ = NULL;
@@ -3182,14 +3193,14 @@ bool VivaldiCoordinates::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
input, &x_coordinate_)));
- _set_bit(0);
+ 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) ==
@@ -3198,14 +3209,14 @@ bool VivaldiCoordinates::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
input, &y_coordinate_)));
- _set_bit(1);
+ 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) ==
@@ -3214,14 +3225,14 @@ bool VivaldiCoordinates::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
input, &local_error_)));
- _set_bit(2);
+ set_has_local_error();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3241,20 +3252,20 @@ bool VivaldiCoordinates::MergePartialFromCodedStream(
void VivaldiCoordinates::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required double x_coordinate = 1;
- if (_has_bit(0)) {
+ if (has_x_coordinate()) {
::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->x_coordinate(), output);
}
-
+
// required double y_coordinate = 2;
- if (_has_bit(1)) {
+ if (has_y_coordinate()) {
::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->y_coordinate(), output);
}
-
+
// required double local_error = 3;
- if (_has_bit(2)) {
+ 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);
@@ -3264,20 +3275,20 @@ void VivaldiCoordinates::SerializeWithCachedSizes(
::google::protobuf::uint8* VivaldiCoordinates::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required double x_coordinate = 1;
- if (_has_bit(0)) {
+ if (has_x_coordinate()) {
target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->x_coordinate(), target);
}
-
+
// required double y_coordinate = 2;
- if (_has_bit(1)) {
+ if (has_y_coordinate()) {
target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->y_coordinate(), target);
}
-
+
// required double local_error = 3;
- if (_has_bit(2)) {
+ 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);
@@ -3287,23 +3298,23 @@ void VivaldiCoordinates::SerializeWithCachedSizes(
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 +=
@@ -3331,13 +3342,13 @@ void VivaldiCoordinates::MergeFrom(const ::google::protobuf::Message& from) {
void VivaldiCoordinates::MergeFrom(const VivaldiCoordinates& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_x_coordinate()) {
set_x_coordinate(from.x_coordinate());
}
- if (from._has_bit(1)) {
+ if (from.has_y_coordinate()) {
set_y_coordinate(from.y_coordinate());
}
- if (from._has_bit(2)) {
+ if (from.has_local_error()) {
set_local_error(from.local_error());
}
}
@@ -3358,7 +3369,7 @@ void VivaldiCoordinates::CopyFrom(const VivaldiCoordinates& from) {
bool VivaldiCoordinates::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -3430,7 +3441,8 @@ const ::google::protobuf::Descriptor* OSDWriteResponse::descriptor() {
}
const OSDWriteResponse& OSDWriteResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
OSDWriteResponse* OSDWriteResponse::default_instance_ = NULL;
@@ -3461,14 +3473,14 @@ bool OSDWriteResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &size_in_bytes_)));
- _set_bit(0);
+ 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) ==
@@ -3477,14 +3489,14 @@ bool OSDWriteResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &truncate_epoch_)));
- _set_bit(1);
+ set_has_truncate_epoch();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3504,15 +3516,15 @@ bool OSDWriteResponse::MergePartialFromCodedStream(
void OSDWriteResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional fixed64 size_in_bytes = 1;
- if (_has_bit(0)) {
+ if (has_size_in_bytes()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->size_in_bytes(), output);
}
-
+
// optional fixed32 truncate_epoch = 2;
- if (_has_bit(1)) {
+ 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);
@@ -3522,15 +3534,15 @@ void OSDWriteResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* OSDWriteResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional fixed64 size_in_bytes = 1;
- if (_has_bit(0)) {
+ if (has_size_in_bytes()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->size_in_bytes(), target);
}
-
+
// optional fixed32 truncate_epoch = 2;
- if (_has_bit(1)) {
+ 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);
@@ -3540,18 +3552,18 @@ void OSDWriteResponse::SerializeWithCachedSizes(
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 +=
@@ -3579,10 +3591,10 @@ void OSDWriteResponse::MergeFrom(const ::google::protobuf::Message& from) {
void OSDWriteResponse::MergeFrom(const OSDWriteResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_size_in_bytes()) {
set_size_in_bytes(from.size_in_bytes());
}
- if (from._has_bit(1)) {
+ if (from.has_truncate_epoch()) {
set_truncate_epoch(from.truncate_epoch());
}
}
@@ -3602,7 +3614,7 @@ void OSDWriteResponse::CopyFrom(const OSDWriteResponse& from) {
}
bool OSDWriteResponse::IsInitialized() const {
-
+
return true;
}
@@ -3627,8 +3639,6 @@ void OSDWriteResponse::Swap(OSDWriteResponse* other) {
// ===================================================================
-const ::std::string KeyValuePair::_default_key_;
-const ::std::string KeyValuePair::_default_value_;
#ifndef _MSC_VER
const int KeyValuePair::kKeyFieldNumber;
const int KeyValuePair::kValueFieldNumber;
@@ -3650,8 +3660,8 @@ KeyValuePair::KeyValuePair(const KeyValuePair& from)
void KeyValuePair::SharedCtor() {
_cached_size_ = 0;
- key_ = const_cast< ::std::string*>(&_default_key_);
- value_ = const_cast< ::std::string*>(&_default_value_);
+ 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_));
}
@@ -3660,10 +3670,10 @@ KeyValuePair::~KeyValuePair() {
}
void KeyValuePair::SharedDtor() {
- if (key_ != &_default_key_) {
+ if (key_ != &::google::protobuf::internal::kEmptyString) {
delete key_;
}
- if (value_ != &_default_value_) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
delete value_;
}
if (this != default_instance_) {
@@ -3681,7 +3691,8 @@ const ::google::protobuf::Descriptor* KeyValuePair::descriptor() {
}
const KeyValuePair& KeyValuePair::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ return *default_instance_;
}
KeyValuePair* KeyValuePair::default_instance_ = NULL;
@@ -3692,13 +3703,13 @@ KeyValuePair* KeyValuePair::New() const {
void KeyValuePair::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (key_ != &_default_key_) {
+ if (has_key()) {
+ if (key_ != &::google::protobuf::internal::kEmptyString) {
key_->clear();
}
}
- if (_has_bit(1)) {
- if (value_ != &_default_value_) {
+ if (has_value()) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
value_->clear();
}
}
@@ -3728,7 +3739,7 @@ bool KeyValuePair::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_value;
break;
}
-
+
// required string value = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3745,7 +3756,7 @@ bool KeyValuePair::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3765,23 +3776,23 @@ bool KeyValuePair::MergePartialFromCodedStream(
void KeyValuePair::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string key = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->value(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -3791,7 +3802,7 @@ void KeyValuePair::SerializeWithCachedSizes(
::google::protobuf::uint8* KeyValuePair::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string key = 1;
- if (_has_bit(0)) {
+ if (has_key()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->key().data(), this->key().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -3799,9 +3810,9 @@ void KeyValuePair::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->key(), target);
}
-
+
// required string value = 2;
- if (_has_bit(1)) {
+ if (has_value()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->value().data(), this->value().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -3809,7 +3820,7 @@ void KeyValuePair::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->value(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -3819,7 +3830,7 @@ void KeyValuePair::SerializeWithCachedSizes(
int KeyValuePair::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string key = 1;
if (has_key()) {
@@ -3827,14 +3838,14 @@ int KeyValuePair::ByteSize() const {
::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 +=
@@ -3862,10 +3873,10 @@ void KeyValuePair::MergeFrom(const ::google::protobuf::Message& from) {
void KeyValuePair::MergeFrom(const KeyValuePair& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_key()) {
set_key(from.key());
}
- if (from._has_bit(1)) {
+ if (from.has_value()) {
set_value(from.value());
}
}
@@ -3886,7 +3897,7 @@ void KeyValuePair::CopyFrom(const KeyValuePair& from) {
bool KeyValuePair::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
diff --git a/cpp/generated/xtreemfs/GlobalTypes.pb.h b/cpp/generated/xtreemfs/GlobalTypes.pb.h
index 5476d9241c6e2137c3e865d7af6081945227e460..50872124247d3e00e7a86e81913a9f7d1187be1b 100644
--- a/cpp/generated/xtreemfs/GlobalTypes.pb.h
+++ b/cpp/generated/xtreemfs/GlobalTypes.pb.h
@@ -8,21 +8,23 @@
#include
-#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#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 "include/PBRPC.pb.h"
#include "include/Common.pb.h"
// @@protoc_insertion_point(includes)
@@ -270,29 +272,29 @@ 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);
@@ -300,7 +302,7 @@ class NewFileSize : public ::google::protobuf::Message {
void MergeFrom(const NewFileSize& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -313,51 +315,46 @@ class NewFileSize : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static NewFileSize* default_instance_;
};
@@ -367,29 +364,29 @@ 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);
@@ -397,7 +394,7 @@ class StripingPolicy : public ::google::protobuf::Message {
void MergeFrom(const StripingPolicy& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -410,59 +407,56 @@ class StripingPolicy : public ::google::protobuf::Message {
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);
-
+ 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);
-
+
// @@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();
+
::google::protobuf::UnknownFieldSet _unknown_fields_;
- mutable int _cached_size_;
-
+
int type_;
::google::protobuf::uint32 stripe_size_;
::google::protobuf::uint32 width_;
+
+ 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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static StripingPolicy* default_instance_;
};
@@ -472,29 +466,29 @@ 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);
@@ -502,7 +496,7 @@ class Replica : public ::google::protobuf::Message {
void MergeFrom(const Replica& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -515,13 +509,13 @@ class Replica : public ::google::protobuf::Message {
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();
@@ -537,46 +531,43 @@ class Replica : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::google::protobuf::RepeatedPtrField< ::std::string> osd_uuids_;
- ::google::protobuf::uint32 replication_flags_;
::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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Replica* default_instance_;
};
@@ -586,29 +577,29 @@ 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);
@@ -616,7 +607,7 @@ class Replicas : public ::google::protobuf::Message {
void MergeFrom(const Replicas& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -629,13 +620,13 @@ class Replicas : public ::google::protobuf::Message {
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();
@@ -647,30 +638,21 @@ class Replicas : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Replicas* default_instance_;
};
@@ -680,29 +662,29 @@ 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);
@@ -710,7 +692,7 @@ class XCap : public ::google::protobuf::Message {
void MergeFrom(const XCap& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -723,20 +705,20 @@ class XCap : public ::google::protobuf::Message {
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();
@@ -746,21 +728,23 @@ class XCap : public ::google::protobuf::Message {
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();
@@ -770,14 +754,16 @@ class XCap : public ::google::protobuf::Message {
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();
@@ -787,63 +773,73 @@ class XCap : public ::google::protobuf::Message {
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);
-
+ 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_;
- mutable int _cached_size_;
-
- ::google::protobuf::uint32 access_mode_;
+
::std::string* client_identity_;
- static const ::std::string _default_client_identity_;
- ::google::protobuf::uint64 expire_time_s_;
+ ::google::protobuf::uint32 access_mode_;
::google::protobuf::uint32 expire_timeout_s_;
+ ::google::protobuf::uint64 expire_time_s_;
::std::string* file_id_;
- static const ::std::string _default_file_id_;
- bool replicate_on_close_;
::std::string* server_signature_;
- static const ::std::string _default_server_signature_;
+ bool replicate_on_close_;
::google::protobuf::uint32 truncate_epoch_;
- int snap_config_;
::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();
-
- ::google::protobuf::uint32 _has_bits_[(10 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static XCap* default_instance_;
};
@@ -853,29 +849,29 @@ 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);
@@ -883,7 +879,7 @@ class XLocSet : public ::google::protobuf::Message {
void MergeFrom(const XLocSet& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -896,20 +892,20 @@ class XLocSet : public ::google::protobuf::Message {
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();
@@ -921,7 +917,7 @@ class XLocSet : public ::google::protobuf::Message {
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();
@@ -931,41 +927,39 @@ class XLocSet : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::google::protobuf::uint64 read_only_file_size_;
::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Replica > replicas_;
::std::string* replica_update_policy_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static XLocSet* default_instance_;
};
@@ -975,29 +969,29 @@ 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);
@@ -1005,7 +999,7 @@ class FileCredentials : public ::google::protobuf::Message {
void MergeFrom(const FileCredentials& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1018,51 +1012,50 @@ class FileCredentials : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static FileCredentials* default_instance_;
};
@@ -1072,29 +1065,29 @@ 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);
@@ -1102,7 +1095,7 @@ class FileCredentialsSet : public ::google::protobuf::Message {
void MergeFrom(const FileCredentialsSet& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1115,43 +1108,38 @@ class FileCredentialsSet : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static FileCredentialsSet* default_instance_;
};
@@ -1161,29 +1149,29 @@ 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);
@@ -1191,7 +1179,7 @@ class VivaldiCoordinates : public ::google::protobuf::Message {
void MergeFrom(const VivaldiCoordinates& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1204,59 +1192,56 @@ class VivaldiCoordinates : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static VivaldiCoordinates* default_instance_;
};
@@ -1266,29 +1251,29 @@ 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);
@@ -1296,7 +1281,7 @@ class OSDWriteResponse : public ::google::protobuf::Message {
void MergeFrom(const OSDWriteResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1309,51 +1294,46 @@ class OSDWriteResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static OSDWriteResponse* default_instance_;
};
@@ -1363,29 +1343,29 @@ 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);
@@ -1393,7 +1373,7 @@ class KeyValuePair : public ::google::protobuf::Message {
void MergeFrom(const KeyValuePair& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1406,13 +1386,13 @@ class KeyValuePair : public ::google::protobuf::Message {
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();
@@ -1422,7 +1402,9 @@ class KeyValuePair : public ::google::protobuf::Message {
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();
@@ -1432,33 +1414,28 @@ class KeyValuePair : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* key_;
- static const ::std::string _default_key_;
::std::string* value_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static KeyValuePair* default_instance_;
};
@@ -1471,33 +1448,45 @@ class KeyValuePair : public ::google::protobuf::Message {
// required fixed64 size_in_bytes = 1;
inline bool NewFileSize::has_size_in_bytes() const {
- return _has_bit(0);
+ 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_bit(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_bit(0);
+ set_has_size_in_bytes();
size_in_bytes_ = value;
}
// required fixed32 truncate_epoch = 2;
inline bool NewFileSize::has_truncate_epoch() const {
- return _has_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ set_has_truncate_epoch();
truncate_epoch_ = value;
}
@@ -1507,50 +1496,68 @@ inline void NewFileSize::set_truncate_epoch(::google::protobuf::uint32 value) {
// required .xtreemfs.pbrpc.StripingPolicyType type = 1;
inline bool StripingPolicy::has_type() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_type();
}
-inline xtreemfs::pbrpc::StripingPolicyType StripingPolicy::type() const {
- return static_cast< xtreemfs::pbrpc::StripingPolicyType >(type_);
+inline ::xtreemfs::pbrpc::StripingPolicyType StripingPolicy::type() const {
+ return static_cast< ::xtreemfs::pbrpc::StripingPolicyType >(type_);
}
-inline void StripingPolicy::set_type(xtreemfs::pbrpc::StripingPolicyType value) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::StripingPolicyType_IsValid(value));
- _set_bit(0);
+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_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ set_has_stripe_size();
stripe_size_ = value;
}
// required fixed32 width = 3;
inline bool StripingPolicy::has_width() const {
- return _has_bit(2);
+ 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_bit(2);
+ clear_has_width();
}
inline ::google::protobuf::uint32 StripingPolicy::width() const {
return width_;
}
inline void StripingPolicy::set_width(::google::protobuf::uint32 value) {
- _set_bit(2);
+ set_has_width();
width_ = value;
}
@@ -1604,36 +1611,63 @@ Replica::mutable_osd_uuids() {
// required fixed32 replication_flags = 2;
inline bool Replica::has_replication_flags() const {
- return _has_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ set_has_replication_flags();
replication_flags_ = value;
}
// required .xtreemfs.pbrpc.StripingPolicy striping_policy = 3;
inline bool Replica::has_striping_policy() const {
- return _has_bit(2);
+ 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_bit(2);
+ 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_bit(2);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -1670,240 +1704,366 @@ Replicas::mutable_replicas() {
// required fixed32 access_mode = 1;
inline bool XCap::has_access_mode() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ set_has_access_mode();
access_mode_ = value;
}
// required string client_identity = 2;
inline bool XCap::has_client_identity() const {
- return _has_bit(1);
+ 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_ != &_default_client_identity_) {
+ if (client_identity_ != &::google::protobuf::internal::kEmptyString) {
client_identity_->clear();
}
- _clear_bit(1);
+ 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_bit(1);
- if (client_identity_ == &_default_client_identity_) {
+ 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_bit(1);
- if (client_identity_ == &_default_client_identity_) {
+ 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_bit(1);
- if (client_identity_ == &_default_client_identity_) {
+ 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_bit(1);
- if (client_identity_ == &_default_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_bit(2);
+ 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_bit(2);
+ 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_bit(2);
+ 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_bit(3);
+ 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_bit(3);
+ 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_bit(3);
+ set_has_expire_timeout_s();
expire_timeout_s_ = value;
}
// required string file_id = 5;
inline bool XCap::has_file_id() const {
- return _has_bit(4);
+ 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_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
- _clear_bit(4);
+ 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_bit(4);
- if (file_id_ == &_default_file_id_) {
+ 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_bit(4);
- if (file_id_ == &_default_file_id_) {
+ 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_bit(4);
- if (file_id_ == &_default_file_id_) {
+ 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_bit(4);
- if (file_id_ == &_default_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_bit(5);
+ 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_bit(5);
+ 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_bit(5);
+ set_has_replicate_on_close();
replicate_on_close_ = value;
}
// required string server_signature = 7;
inline bool XCap::has_server_signature() const {
- return _has_bit(6);
+ 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_ != &_default_server_signature_) {
+ if (server_signature_ != &::google::protobuf::internal::kEmptyString) {
server_signature_->clear();
}
- _clear_bit(6);
+ 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_bit(6);
- if (server_signature_ == &_default_server_signature_) {
+ 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_bit(6);
- if (server_signature_ == &_default_server_signature_) {
+ 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_bit(6);
- if (server_signature_ == &_default_server_signature_) {
+ 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_bit(6);
- if (server_signature_ == &_default_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_bit(7);
+ 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_bit(7);
+ 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_bit(7);
+ set_has_truncate_epoch();
truncate_epoch_ = value;
}
// required .xtreemfs.pbrpc.SnapConfig snap_config = 9;
inline bool XCap::has_snap_config() const {
- return _has_bit(8);
+ 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_bit(8);
+ clear_has_snap_config();
}
-inline xtreemfs::pbrpc::SnapConfig XCap::snap_config() const {
- return static_cast< xtreemfs::pbrpc::SnapConfig >(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) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::SnapConfig_IsValid(value));
- _set_bit(8);
+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_bit(9);
+ 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_bit(9);
+ 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_bit(9);
+ set_has_snap_timestamp();
snap_timestamp_ = value;
}
@@ -1913,17 +2073,23 @@ inline void XCap::set_snap_timestamp(::google::protobuf::uint64 value) {
// required fixed64 read_only_file_size = 1;
inline bool XLocSet::has_read_only_file_size() const {
- return _has_bit(0);
+ 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_bit(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_bit(0);
+ set_has_read_only_file_size();
read_only_file_size_ = value;
}
@@ -1954,59 +2120,93 @@ XLocSet::mutable_replicas() {
// required string replica_update_policy = 3;
inline bool XLocSet::has_replica_update_policy() const {
- return _has_bit(2);
+ 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_ != &_default_replica_update_policy_) {
+ if (replica_update_policy_ != &::google::protobuf::internal::kEmptyString) {
replica_update_policy_->clear();
}
- _clear_bit(2);
+ 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_bit(2);
- if (replica_update_policy_ == &_default_replica_update_policy_) {
+ 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_bit(2);
- if (replica_update_policy_ == &_default_replica_update_policy_) {
+ 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_bit(2);
- if (replica_update_policy_ == &_default_replica_update_policy_) {
+ 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_bit(2);
- if (replica_update_policy_ == &_default_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_bit(3);
+ 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_bit(3);
+ clear_has_version();
}
inline ::google::protobuf::uint32 XLocSet::version() const {
return version_;
}
inline void XLocSet::set_version(::google::protobuf::uint32 value) {
- _set_bit(3);
+ set_has_version();
version_ = value;
}
@@ -2016,37 +2216,79 @@ inline void XLocSet::set_version(::google::protobuf::uint32 value) {
// required .xtreemfs.pbrpc.XCap xcap = 1;
inline bool FileCredentials::has_xcap() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ 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_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -2054,20 +2296,41 @@ inline ::xtreemfs::pbrpc::XLocSet* FileCredentials::mutable_xlocs() {
// optional .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
inline bool FileCredentialsSet::has_file_credentials() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -2075,49 +2338,67 @@ inline ::xtreemfs::pbrpc::FileCredentials* FileCredentialsSet::mutable_file_cred
// required double x_coordinate = 1;
inline bool VivaldiCoordinates::has_x_coordinate() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_x_coordinate();
}
inline double VivaldiCoordinates::x_coordinate() const {
return x_coordinate_;
}
inline void VivaldiCoordinates::set_x_coordinate(double value) {
- _set_bit(0);
+ set_has_x_coordinate();
x_coordinate_ = value;
}
// required double y_coordinate = 2;
inline bool VivaldiCoordinates::has_y_coordinate() const {
- return _has_bit(1);
+ 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_bit(1);
+ clear_has_y_coordinate();
}
inline double VivaldiCoordinates::y_coordinate() const {
return y_coordinate_;
}
inline void VivaldiCoordinates::set_y_coordinate(double value) {
- _set_bit(1);
+ set_has_y_coordinate();
y_coordinate_ = value;
}
// required double local_error = 3;
inline bool VivaldiCoordinates::has_local_error() const {
- return _has_bit(2);
+ 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_bit(2);
+ clear_has_local_error();
}
inline double VivaldiCoordinates::local_error() const {
return local_error_;
}
inline void VivaldiCoordinates::set_local_error(double value) {
- _set_bit(2);
+ set_has_local_error();
local_error_ = value;
}
@@ -2127,33 +2408,45 @@ inline void VivaldiCoordinates::set_local_error(double value) {
// optional fixed64 size_in_bytes = 1;
inline bool OSDWriteResponse::has_size_in_bytes() const {
- return _has_bit(0);
+ 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_bit(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_bit(0);
+ set_has_size_in_bytes();
size_in_bytes_ = value;
}
// optional fixed32 truncate_epoch = 2;
inline bool OSDWriteResponse::has_truncate_epoch() const {
- return _has_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ set_has_truncate_epoch();
truncate_epoch_ = value;
}
@@ -2163,87 +2456,143 @@ inline void OSDWriteResponse::set_truncate_epoch(::google::protobuf::uint32 valu
// required string key = 1;
inline bool KeyValuePair::has_key() const {
- return _has_bit(0);
+ 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_ != &_default_key_) {
+ if (key_ != &::google::protobuf::internal::kEmptyString) {
key_->clear();
}
- _clear_bit(0);
+ clear_has_key();
}
inline const ::std::string& KeyValuePair::key() const {
return *key_;
}
inline void KeyValuePair::set_key(const ::std::string& value) {
- _set_bit(0);
- if (key_ == &_default_key_) {
+ 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_bit(0);
- if (key_ == &_default_key_) {
+ 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_bit(0);
- if (key_ == &_default_key_) {
+ 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_bit(0);
- if (key_ == &_default_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_bit(1);
+ 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_ != &_default_value_) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
value_->clear();
}
- _clear_bit(1);
+ clear_has_value();
}
inline const ::std::string& KeyValuePair::value() const {
return *value_;
}
inline void KeyValuePair::set_value(const ::std::string& value) {
- _set_bit(1);
- if (value_ == &_default_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_bit(1);
- if (value_ == &_default_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_bit(1);
- if (value_ == &_default_value_) {
+ 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_bit(1);
- if (value_ == &_default_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)
@@ -2256,44 +2605,44 @@ namespace google {
namespace protobuf {
template <>
-inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::AccessControlPolicyType>() {
- return xtreemfs::pbrpc::AccessControlPolicyType_descriptor();
+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();
+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();
+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();
+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();
+inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::StripingPolicyType>() {
+ return ::xtreemfs::pbrpc::StripingPolicyType_descriptor();
}
template <>
-inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::PORTS>() {
- return xtreemfs::pbrpc::PORTS_descriptor();
+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();
+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();
+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();
+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();
+inline const EnumDescriptor* GetEnumDescriptor< ::xtreemfs::pbrpc::SERVICES>() {
+ return ::xtreemfs::pbrpc::SERVICES_descriptor();
}
} // namespace google
diff --git a/cpp/generated/xtreemfs/MRC.pb.cc b/cpp/generated/xtreemfs/MRC.pb.cc
index 56e979c5152240e03e3080b9f579fd014f36bf09..1a2d2e248e572ce07cb16714a1854d8b0aa90cc7 100644
--- a/cpp/generated/xtreemfs/MRC.pb.cc
+++ b/cpp/generated/xtreemfs/MRC.pb.cc
@@ -1,11 +1,17 @@
// 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)
@@ -174,7 +180,6 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
const ::google::protobuf::EnumDescriptor* Setattrs_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* XATTR_FLAGS_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ACCESS_FLAGS_descriptor_ = NULL;
-const ::google::protobuf::ServiceDescriptor* MRCService_descriptor_ = NULL;
} // namespace
@@ -248,7 +253,7 @@ void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto() {
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_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XAttr, value_bytes_string_),
};
XAttr_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -299,9 +304,10 @@ void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto() {
::google::protobuf::MessageFactory::generated_factory(),
sizeof(Volumes));
StatVFS_descriptor_ = file->message_type(6);
- static const int StatVFS_offsets_[12] = {
+ 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_),
@@ -393,7 +399,7 @@ void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto() {
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_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(getxattrResponse, value_bytes_string_),
};
getxattrResponse_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -649,7 +655,7 @@ void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto() {
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_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, value_bytes_string_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(setxattrRequest, flags_),
};
setxattrRequest_reflection_ =
@@ -1070,7 +1076,6 @@ void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto() {
Setattrs_descriptor_ = file->enum_type(0);
XATTR_FLAGS_descriptor_ = file->enum_type(1);
ACCESS_FLAGS_descriptor_ = file->enum_type(2);
- MRCService_descriptor_ = file->service(0);
}
namespace {
@@ -1320,223 +1325,224 @@ void protobuf_AddDesc_xtreemfs_2fMRC_2eproto() {
"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\"9\n\005XAttr\022\014\n\004name\030\001 \002(\t\022\r\n\005value\030"
- "\002 \001(\t\022\023\n\013value_bytes\030\003 \001(\014\"\225\002\n\006Volume\022F\n"
- "\025access_control_policy\030\001 \002(\0162\'.xtreemfs."
- "pbrpc.AccessControlPolicyType\022?\n\027default"
- "_striping_policy\030\002 \002(\0132\036.xtreemfs.pbrpc."
- "StripingPolicy\022\n\n\002id\030\003 \002(\t\022\014\n\004mode\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.x"
- "treemfs.pbrpc.KeyValuePair\"2\n\007Volumes\022\'\n"
- "\007volumes\030\001 \003(\0132\026.xtreemfs.pbrpc.Volume\"\271"
- "\002\n\007StatVFS\022\r\n\005bsize\030\001 \002(\007\022\016\n\006bavail\030\002 \002("
- "\006\022\016\n\006blocks\030\003 \002(\006\022\014\n\004fsid\030\004 \002(\t\022\017\n\007namem"
- "ax\030\005 \002(\007\022F\n\025access_control_policy\030\006 \002(\0162"
- "\'.xtreemfs.pbrpc.AccessControlPolicyType"
- "\022?\n\027default_striping_policy\030\007 \002(\0132\036.xtre"
- "emfs.pbrpc.StripingPolicy\022\014\n\004etag\030\010 \002(\006\022"
- "\014\n\004mode\030\t \002(\007\022\014\n\004name\030\n \002(\t\022\026\n\016owner_gro"
- "up_id\030\013 \002(\t\022\025\n\rowner_user_id\030\014 \002(\t\"i\n\017fs"
- "etattrRequest\022#\n\005stbuf\030\001 \002(\0132\024.xtreemfs."
- "pbrpc.Stat\022\016\n\006to_set\030\002 \002(\007\022!\n\003cap\030\003 \002(\0132"
- "\024.xtreemfs.pbrpc.XCap\"G\n\016getattrRequest\022"
- "\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\022\022\n\nkn"
- "own_etag\030\003 \002(\006\"6\n\017getattrResponse\022#\n\005stb"
- "uf\030\001 \001(\0132\024.xtreemfs.pbrpc.Stat\"B\n\017getxat"
- "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\"6\n\020getxattrResponse\022\r"
- "\n\005value\030\001 \002(\t\022\023\n\013value_bytes\030\002 \001(\014\"J\n\013li"
- "nkRequest\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\"I\n\020listxa"
- "ttrRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030"
- "\002 \002(\t\022\022\n\nnames_only\030\003 \002(\010\":\n\021listxattrRe"
- "sponse\022%\n\006xattrs\030\001 \003(\0132\025.xtreemfs.pbrpc."
- "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\013openR"
- "equest\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\nattrib"
- "utes\030\005 \002(\007\0227\n\013coordinates\030\006 \001(\0132\".xtreem"
- "fs.pbrpc.VivaldiCoordinates\"S\n\014openRespo"
- "nse\022.\n\005creds\030\001 \002(\0132\037.xtreemfs.pbrpc.File"
- "Credentials\022\023\n\013timestamp_s\030\002 \002(\007\"\250\001\n\016rea"
- "ddirRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path"
- "\030\002 \002(\t\022\022\n\nknown_etag\030\003 \002(\006\022%\n\035limit_dire"
- "ctory_entries_count\030\004 \002(\007\022\022\n\nnames_only\030"
- "\005 \002(\010\022$\n\034seen_directory_entries_count\030\006 "
- "\002(\006\"4\n\017readlinkRequest\022\023\n\013volume_name\030\001 "
- "\002(\t\022\014\n\004path\030\002 \002(\t\",\n\020readlinkResponse\022\030\n"
- "\020link_target_path\030\001 \003(\t\"E\n\022removexattrRe"
- "quest\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\013volum"
- "e_name\030\001 \002(\t\022\023\n\013source_path\030\002 \002(\t\022\023\n\013tar"
- "get_path\030\003 \002(\t\"U\n\016renameResponse\022\023\n\013time"
- "stamp_s\030\001 \002(\007\022.\n\005creds\030\002 \001(\0132\037.xtreemfs."
- "pbrpc.FileCredentials\"1\n\014rmdirRequest\022\023\n"
- "\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\"h\n\016seta"
- "ttrRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030"
- "\002 \002(\t\022#\n\005stbuf\030\003 \002(\0132\024.xtreemfs.pbrpc.St"
- "at\022\016\n\006to_set\030\004 \002(\007\"u\n\017setxattrRequest\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\022\r\n\005value\030\004 \002(\t\022\023\n\013value_bytes\030\006 \001"
- "(\014\022\r\n\005flags\030\005 \002(\007\"9\n\016statvfsRequest\022\023\n\013v"
- "olume_name\030\001 \002(\t\022\022\n\nknown_etag\030\005 \002(\006\"M\n\016"
- "symlinkRequest\022\023\n\013volume_name\030\001 \002(\t\022\023\n\013t"
- "arget_path\030\002 \002(\t\022\021\n\tlink_path\030\003 \002(\t\"2\n\ru"
- "nlinkRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004pat"
- "h\030\002 \002(\t\"U\n\016unlinkResponse\022\023\n\013timestamp_s"
- "\030\001 \002(\007\022.\n\005creds\030\002 \001(\0132\037.xtreemfs.pbrpc.F"
- "ileCredentials\"A\n\raccessRequest\022\023\n\013volum"
- "e_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_existsRequest\022\021"
- "\n\tvolume_id\030\001 \002(\t\022\020\n\010file_ids\030\002 \003(\t\022\020\n\010o"
- "sd_uuid\030\003 \002(\t\":\n%xtreemfs_dump_restore_d"
- "atabaseRequest\022\021\n\tdump_file\030\001 \002(\t\"i\n!xtr"
- "eemfs_get_suitable_osdsRequest\022\017\n\007file_i"
- "d\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_sui"
- "table_osdsResponse\022\021\n\tosd_uuids\030\001 \003(\t\"4\n"
- "\"xtreemfs_check_file_existsResponse\022\016\n\006b"
- "itmap\030\001 \002(\t\"(\n\021timestampResponse\022\023\n\013time"
- "stamp_s\030\001 \002(\007\"!\n\rstringMessage\022\020\n\010a_stri"
- "ng\030\001 \002(\t\"\'\n\027xtreemfs_listdirRequest\022\014\n\004p"
- "ath\030\001 \002(\t\")\n\030xtreemfs_listdirResponse\022\r\n"
- "\005names\030\001 \003(\t\"\177\n\033xtreemfs_replica_addRequ"
- "est\022\017\n\007file_id\030\001 \001(\t\022\014\n\004path\030\003 \001(\t\022\023\n\013vo"
- "lume_name\030\004 \001(\t\022,\n\013new_replica\030\002 \002(\0132\027.x"
- "treemfs.pbrpc.Replica\"R\n\034xtreemfs_replic"
- "a_listRequest\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\"f\n\036xtreemfs_re"
- "plica_removeRequest\022\017\n\007file_id\030\001 \001(\t\022\014\n\004"
- "path\030\003 \001(\t\022\023\n\013volume_name\030\004 \001(\t\022\020\n\010osd_u"
- "uid\030\002 \002(\t\"|\n\034xtreemfs_restore_fileReques"
- "t\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\013st"
- "ripe_size\030\005 \002(\007\",\n\025xtreemfs_rmvolRequest"
- "\022\023\n\013volume_name\030\001 \002(\t\"\321\001\n xtreemfs_updat"
- "e_file_sizeRequest\022\"\n\004xcap\030\001 \002(\0132\024.xtree"
- "mfs.pbrpc.XCap\022<\n\022osd_write_response\030\002 \002"
- "(\0132 .xtreemfs.pbrpc.OSDWriteResponse\022\022\n\n"
- "close_file\030\003 \001(\010\0227\n\013coordinates\030\004 \001(\0132\"."
- "xtreemfs.pbrpc.VivaldiCoordinates\"S\n)xtr"
- "eemfs_set_replica_update_policyRequest\022\017"
- "\n\007file_id\030\001 \002(\t\022\025\n\rupdate_policy\030\002 \002(\t\"G"
- "\n*xtreemfs_set_replica_update_policyResp"
- "onse\022\031\n\021old_update_policy\030\001 \002(\t\"E\n#xtree"
- "mfs_set_read_only_xattrRequest\022\017\n\007file_i"
- "d\030\001 \002(\t\022\r\n\005value\030\002 \002(\010\"7\n$xtreemfs_set_r"
- "ead_only_xattrResponse\022\017\n\007was_set\030\001 \002(\010\""
- "7\n$xtreemfs_get_file_credentialsRequest\022"
- "\017\n\007file_id\030\001 \002(\t*\242\001\n\010Setattrs\022\020\n\014SETATTR"
- "_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\022"
- "SETATTR_ATTRIBUTES\020\200\001*>\n\013XATTR_FLAGS\022\026\n\022"
- "XATTR_FLAGS_CREATE\020\001\022\027\n\023XATTR_FLAGS_REPL"
- "ACE\020\002*j\n\014ACCESS_FLAGS\022\025\n\021ACCESS_FLAGS_F_"
- "OK\020\000\022\025\n\021ACCESS_FLAGS_X_OK\020\001\022\025\n\021ACCESS_FL"
- "AGS_W_OK\020\002\022\025\n\021ACCESS_FLAGS_R_OK\020\0042\234\037\n\nMR"
- "CService\022S\n\010fsetattr\022\037.xtreemfs.pbrpc.fs"
- "etattrRequest\032\035.xtreemfs.pbrpc.emptyResp"
- "onse\"\007\215\265\030\002\000\000\000\022@\n\tftruncate\022\024.xtreemfs.pb"
- "rpc.XCap\032\024.xtreemfs.pbrpc.XCap\"\007\215\265\030\003\000\000\000\022"
- "S\n\007getattr\022\036.xtreemfs.pbrpc.getattrReque"
- "st\032\037.xtreemfs.pbrpc.getattrResponse\"\007\215\265\030"
- "\004\000\000\000\022V\n\010getxattr\022\037.xtreemfs.pbrpc.getxat"
- "trRequest\032 .xtreemfs.pbrpc.getxattrRespo"
- "nse\"\007\215\265\030\005\000\000\000\022O\n\004link\022\033.xtreemfs.pbrpc.li"
- "nkRequest\032!.xtreemfs.pbrpc.timestampResp"
- "onse\"\007\215\265\030\006\000\000\000\022Y\n\tlistxattr\022 .xtreemfs.pb"
- "rpc.listxattrRequest\032!.xtreemfs.pbrpc.li"
- "stxattrResponse\"\007\215\265\030\007\000\000\000\022Q\n\005mkdir\022\034.xtre"
- "emfs.pbrpc.mkdirRequest\032!.xtreemfs.pbrpc"
- ".timestampResponse\"\007\215\265\030\010\000\000\000\022J\n\004open\022\033.xt"
- "reemfs.pbrpc.openRequest\032\034.xtreemfs.pbrp"
- "c.openResponse\"\007\215\265\030\t\000\000\000\022T\n\007readdir\022\036.xtr"
- "eemfs.pbrpc.readdirRequest\032 .xtreemfs.pb"
- "rpc.DirectoryEntries\"\007\215\265\030\n\000\000\000\022V\n\010readlin"
- "k\022\037.xtreemfs.pbrpc.readlinkRequest\032 .xtr"
- "eemfs.pbrpc.readlinkResponse\"\007\215\265\030\013\000\000\000\022]\n"
- "\013removexattr\022\".xtreemfs.pbrpc.removexatt"
- "rRequest\032!.xtreemfs.pbrpc.timestampRespo"
- "nse\"\007\215\265\030\014\000\000\000\022P\n\006rename\022\035.xtreemfs.pbrpc."
- "renameRequest\032\036.xtreemfs.pbrpc.renameRes"
- "ponse\"\007\215\265\030\r\000\000\000\022Q\n\005rmdir\022\034.xtreemfs.pbrpc"
- ".rmdirRequest\032!.xtreemfs.pbrpc.timestamp"
- "Response\"\007\215\265\030\016\000\000\000\022U\n\007setattr\022\036.xtreemfs."
- "pbrpc.setattrRequest\032!.xtreemfs.pbrpc.ti"
- "mestampResponse\"\007\215\265\030\017\000\000\000\022W\n\010setxattr\022\037.x"
- "treemfs.pbrpc.setxattrRequest\032!.xtreemfs"
- ".pbrpc.timestampResponse\"\007\215\265\030\020\000\000\000\022K\n\007sta"
- "tvfs\022\036.xtreemfs.pbrpc.statvfsRequest\032\027.x"
- "treemfs.pbrpc.StatVFS\"\007\215\265\030\021\000\000\000\022U\n\007symlin"
- "k\022\036.xtreemfs.pbrpc.symlinkRequest\032!.xtre"
- "emfs.pbrpc.timestampResponse\"\007\215\265\030\022\000\000\000\022P\n"
- "\006unlink\022\035.xtreemfs.pbrpc.unlinkRequest\032\036"
- ".xtreemfs.pbrpc.unlinkResponse\"\007\215\265\030\023\000\000\000\022"
- "O\n\006access\022\035.xtreemfs.pbrpc.accessRequest"
- "\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265\030\024\000\000\000"
- "\022[\n\023xtreemfs_checkpoint\022\034.xtreemfs.pbrpc"
- ".emptyRequest\032\035.xtreemfs.pbrpc.emptyResp"
- "onse\"\007\215\265\030\036\000\000\000\022\214\001\n\032xtreemfs_check_file_ex"
- "ists\0221.xtreemfs.pbrpc.xtreemfs_check_fil"
- "e_existsRequest\0322.xtreemfs.pbrpc.xtreemf"
- "s_check_file_existsResponse\"\007\215\265\030\037\000\000\000\022w\n\026"
- "xtreemfs_dump_database\0225.xtreemfs.pbrpc."
- "xtreemfs_dump_restore_databaseRequest\032\035."
- "xtreemfs.pbrpc.emptyResponse\"\007\215\265\030 \000\000\000\022\214\001"
- "\n\032xtreemfs_get_suitable_osds\0221.xtreemfs."
- "pbrpc.xtreemfs_get_suitable_osdsRequest\032"
- "2.xtreemfs.pbrpc.xtreemfs_get_suitable_o"
- "sdsResponse\"\007\215\265\030!\000\000\000\022`\n\027xtreemfs_interna"
- "l_debug\022\035.xtreemfs.pbrpc.stringMessage\032\035"
- ".xtreemfs.pbrpc.stringMessage\"\007\215\265\030\"\000\000\000\022n"
- "\n\020xtreemfs_listdir\022\'.xtreemfs.pbrpc.xtre"
- "emfs_listdirRequest\032(.xtreemfs.pbrpc.xtr"
- "eemfs_listdirResponse\"\007\215\265\030#\000\000\000\022P\n\016xtreem"
- "fs_lsvol\022\034.xtreemfs.pbrpc.emptyRequest\032\027"
- ".xtreemfs.pbrpc.Volumes\"\007\215\265\030$\000\000\000\022P\n\016xtre"
- "emfs_mkvol\022\026.xtreemfs.pbrpc.Volume\032\035.xtr"
- "eemfs.pbrpc.emptyResponse\"\007\215\265\030/\000\000\000\022P\n\031xt"
- "reemfs_renew_capability\022\024.xtreemfs.pbrpc"
- ".XCap\032\024.xtreemfs.pbrpc.XCap\"\007\215\265\030%\000\000\000\022f\n\036"
- "xtreemfs_replication_to_master\022\034.xtreemf"
- "s.pbrpc.emptyRequest\032\035.xtreemfs.pbrpc.em"
- "ptyResponse\"\007\215\265\030&\000\000\000\022k\n\024xtreemfs_replica"
- "_add\022+.xtreemfs.pbrpc.xtreemfs_replica_a"
- "ddRequest\032\035.xtreemfs.pbrpc.emptyResponse"
- "\"\007\215\265\030\'\000\000\000\022h\n\025xtreemfs_replica_list\022,.xtr"
- "eemfs.pbrpc.xtreemfs_replica_listRequest"
- "\032\030.xtreemfs.pbrpc.Replicas\"\007\215\265\030(\000\000\000\022s\n\027x"
- "treemfs_replica_remove\022..xtreemfs.pbrpc."
- "xtreemfs_replica_removeRequest\032\037.xtreemf"
- "s.pbrpc.FileCredentials\"\007\215\265\030)\000\000\000\022z\n\031xtre"
- "emfs_restore_database\0225.xtreemfs.pbrpc.x"
- "treemfs_dump_restore_databaseRequest\032\035.x"
- "treemfs.pbrpc.emptyResponse\"\007\215\265\030*\000\000\000\022m\n\025"
- "xtreemfs_restore_file\022,.xtreemfs.pbrpc.x"
- "treemfs_restore_fileRequest\032\035.xtreemfs.p"
- "brpc.emptyResponse\"\007\215\265\030+\000\000\000\022_\n\016xtreemfs_"
- "rmvol\022%.xtreemfs.pbrpc.xtreemfs_rmvolReq"
- "uest\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265\030"
- ",\000\000\000\022Y\n\021xtreemfs_shutdown\022\034.xtreemfs.pbr"
- "pc.emptyRequest\032\035.xtreemfs.pbrpc.emptyRe"
- "sponse\"\007\215\265\030-\000\000\000\022y\n\031xtreemfs_update_file_"
- "size\0220.xtreemfs.pbrpc.xtreemfs_update_fi"
- "le_sizeRequest\032!.xtreemfs.pbrpc.timestam"
- "pResponse\"\007\215\265\030.\000\000\000\022\244\001\n\"xtreemfs_set_repl"
- "ica_update_policy\0229.xtreemfs.pbrpc.xtree"
- "mfs_set_replica_update_policyRequest\032:.x"
- "treemfs.pbrpc.xtreemfs_set_replica_updat"
- "e_policyResponse\"\007\215\265\0300\000\000\000\022\222\001\n\034xtreemfs_s"
- "et_read_only_xattr\0223.xtreemfs.pbrpc.xtre"
- "emfs_set_read_only_xattrRequest\0324.xtreem"
- "fs.pbrpc.xtreemfs_set_read_only_xattrRes"
- "ponse\"\007\215\265\0301\000\000\000\022\177\n\035xtreemfs_get_file_cred"
- "entials\0224.xtreemfs.pbrpc.xtreemfs_get_fi"
- "le_credentialsRequest\032\037.xtreemfs.pbrpc.F"
- "ileCredentials\"\007\215\265\0302\000\000\000\032\007\225\265\030!N\000\000B(\n&org."
- "xtreemfs.pbrpc.generatedinterfaces", 9154);
+ "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\"\225\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\"2\n\007Vol"
+ "umes\022\'\n\007volumes\030\001 \003(\0132\026.xtreemfs.pbrpc.V"
+ "olume\"\310\002\n\007StatVFS\022\r\n\005bsize\030\001 \002(\007\022\016\n\006bava"
+ "il\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\'.xtreemfs.pbrpc.A"
+ "ccessControlPolicyType\022\?\n\027default_stripi"
+ "ng_policy\030\007 \002(\0132\036.xtreemfs.pbrpc.Stripin"
+ "gPolicy\022\014\n\004etag\030\010 \002(\006\022\014\n\004mode\030\t \002(\007\022\014\n\004n"
+ "ame\030\n \002(\t\022\026\n\016owner_group_id\030\013 \002(\t\022\025\n\rown"
+ "er_user_id\030\014 \002(\t\"i\n\017fsetattrRequest\022#\n\005s"
+ "tbuf\030\001 \002(\0132\024.xtreemfs.pbrpc.Stat\022\016\n\006to_s"
+ "et\030\002 \002(\007\022!\n\003cap\030\003 \002(\0132\024.xtreemfs.pbrpc.X"
+ "Cap\"G\n\016getattrRequest\022\023\n\013volume_name\030\001 \002"
+ "(\t\022\014\n\004path\030\002 \002(\t\022\022\n\nknown_etag\030\003 \002(\006\"6\n\017"
+ "getattrResponse\022#\n\005stbuf\030\001 \001(\0132\024.xtreemf"
+ "s.pbrpc.Stat\"B\n\017getxattrRequest\022\023\n\013volum"
+ "e_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\005value\030\001 \002(\t\022\032\n\022v"
+ "alue_bytes_string\030\002 \001(\014\"J\n\013linkRequest\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\"I\n\020listxattrRequest\022"
+ "\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\022\022\n\nna"
+ "mes_only\030\003 \002(\010\":\n\021listxattrResponse\022%\n\006x"
+ "attrs\030\001 \003(\0132\025.xtreemfs.pbrpc.XAttr\"\?\n\014mk"
+ "dirRequest\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\013openRequest\022\023\n\013v"
+ "olume_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\nattributes\030\005 \002(\007\022"
+ "7\n\013coordinates\030\006 \001(\0132\".xtreemfs.pbrpc.Vi"
+ "valdiCoordinates\"S\n\014openResponse\022.\n\005cred"
+ "s\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\004path\030\002 \002(\t\022\022\n\nk"
+ "nown_etag\030\003 \002(\006\022%\n\035limit_directory_entri"
+ "es_count\030\004 \002(\007\022\022\n\nnames_only\030\005 \002(\010\022$\n\034se"
+ "en_directory_entries_count\030\006 \002(\006\"4\n\017read"
+ "linkRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path"
+ "\030\002 \002(\t\",\n\020readlinkResponse\022\030\n\020link_targe"
+ "t_path\030\001 \003(\t\"E\n\022removexattrRequest\022\023\n\013vo"
+ "lume_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\013volume_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\013timestamp_s\030\001 \002"
+ "(\007\022.\n\005creds\030\002 \001(\0132\037.xtreemfs.pbrpc.FileC"
+ "redentials\"1\n\014rmdirRequest\022\023\n\013volume_nam"
+ "e\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\"h\n\016setattrRequest\022"
+ "\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\022#\n\005st"
+ "buf\030\003 \002(\0132\024.xtreemfs.pbrpc.Stat\022\016\n\006to_se"
+ "t\030\004 \002(\007\"|\n\017setxattrRequest\022\023\n\013volume_nam"
+ "e\030\001 \002(\t\022\014\n\004path\030\002 \002(\t\022\014\n\004name\030\003 \002(\t\022\r\n\005v"
+ "alue\030\004 \002(\t\022\032\n\022value_bytes_string\030\006 \001(\014\022\r"
+ "\n\005flags\030\005 \002(\007\"9\n\016statvfsRequest\022\023\n\013volum"
+ "e_name\030\001 \002(\t\022\022\n\nknown_etag\030\005 \002(\006\"M\n\016syml"
+ "inkRequest\022\023\n\013volume_name\030\001 \002(\t\022\023\n\013targe"
+ "t_path\030\002 \002(\t\022\021\n\tlink_path\030\003 \002(\t\"2\n\runlin"
+ "kRequest\022\023\n\013volume_name\030\001 \002(\t\022\014\n\004path\030\002 "
+ "\002(\t\"U\n\016unlinkResponse\022\023\n\013timestamp_s\030\001 \002"
+ "(\007\022.\n\005creds\030\002 \001(\0132\037.xtreemfs.pbrpc.FileC"
+ "redentials\"A\n\raccessRequest\022\023\n\013volume_na"
+ "me\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_existsRequest\022\021\n\tvo"
+ "lume_id\030\001 \002(\t\022\020\n\010file_ids\030\002 \003(\t\022\020\n\010osd_u"
+ "uid\030\003 \002(\t\":\n%xtreemfs_dump_restore_datab"
+ "aseRequest\022\021\n\tdump_file\030\001 \002(\t\"i\n!xtreemf"
+ "s_get_suitable_osdsRequest\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_suitabl"
+ "e_osdsResponse\022\021\n\tosd_uuids\030\001 \003(\t\"4\n\"xtr"
+ "eemfs_check_file_existsResponse\022\016\n\006bitma"
+ "p\030\001 \002(\t\"(\n\021timestampResponse\022\023\n\013timestam"
+ "p_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_listdirResponse\022\r\n\005nam"
+ "es\030\001 \003(\t\"\177\n\033xtreemfs_replica_addRequest\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.xtree"
+ "mfs.pbrpc.Replica\"R\n\034xtreemfs_replica_li"
+ "stRequest\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\"f\n\036xtreemfs_replic"
+ "a_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\010osd_uuid\030"
+ "\002 \002(\t\"|\n\034xtreemfs_restore_fileRequest\022\021\n"
+ "\tfile_path\030\001 \002(\t\022\017\n\007file_id\030\002 \002(\t\022\021\n\tfil"
+ "e_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_rmvolRequest\022\023\n\013"
+ "volume_name\030\001 \002(\t\"\321\001\n xtreemfs_update_fi"
+ "le_sizeRequest\022\"\n\004xcap\030\001 \002(\0132\024.xtreemfs."
+ "pbrpc.XCap\022<\n\022osd_write_response\030\002 \002(\0132 "
+ ".xtreemfs.pbrpc.OSDWriteResponse\022\022\n\nclos"
+ "e_file\030\003 \001(\010\0227\n\013coordinates\030\004 \001(\0132\".xtre"
+ "emfs.pbrpc.VivaldiCoordinates\"S\n)xtreemf"
+ "s_set_replica_update_policyRequest\022\017\n\007fi"
+ "le_id\030\001 \002(\t\022\025\n\rupdate_policy\030\002 \002(\t\"G\n*xt"
+ "reemfs_set_replica_update_policyResponse"
+ "\022\031\n\021old_update_policy\030\001 \002(\t\"E\n#xtreemfs_"
+ "set_read_only_xattrRequest\022\017\n\007file_id\030\001 "
+ "\002(\t\022\r\n\005value\030\002 \002(\010\"7\n$xtreemfs_set_read_"
+ "only_xattrResponse\022\017\n\007was_set\030\001 \002(\010\"7\n$x"
+ "treemfs_get_file_credentialsRequest\022\017\n\007f"
+ "ile_id\030\001 \002(\t*\242\001\n\010Setattrs\022\020\n\014SETATTR_MOD"
+ "E\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\rSE"
+ "TATTR_MTIME\020 \022\021\n\rSETATTR_CTIME\020@\022\027\n\022SETA"
+ "TTR_ATTRIBUTES\020\200\001*>\n\013XATTR_FLAGS\022\026\n\022XATT"
+ "R_FLAGS_CREATE\020\001\022\027\n\023XATTR_FLAGS_REPLACE\020"
+ "\002*j\n\014ACCESS_FLAGS\022\025\n\021ACCESS_FLAGS_F_OK\020\000"
+ "\022\025\n\021ACCESS_FLAGS_X_OK\020\001\022\025\n\021ACCESS_FLAGS_"
+ "W_OK\020\002\022\025\n\021ACCESS_FLAGS_R_OK\020\0042\234\037\n\nMRCSer"
+ "vice\022S\n\010fsetattr\022\037.xtreemfs.pbrpc.fsetat"
+ "trRequest\032\035.xtreemfs.pbrpc.emptyResponse"
+ "\"\007\215\265\030\002\000\000\000\022@\n\tftruncate\022\024.xtreemfs.pbrpc."
+ "XCap\032\024.xtreemfs.pbrpc.XCap\"\007\215\265\030\003\000\000\000\022S\n\007g"
+ "etattr\022\036.xtreemfs.pbrpc.getattrRequest\032\037"
+ ".xtreemfs.pbrpc.getattrResponse\"\007\215\265\030\004\000\000\000"
+ "\022V\n\010getxattr\022\037.xtreemfs.pbrpc.getxattrRe"
+ "quest\032 .xtreemfs.pbrpc.getxattrResponse\""
+ "\007\215\265\030\005\000\000\000\022O\n\004link\022\033.xtreemfs.pbrpc.linkRe"
+ "quest\032!.xtreemfs.pbrpc.timestampResponse"
+ "\"\007\215\265\030\006\000\000\000\022Y\n\tlistxattr\022 .xtreemfs.pbrpc."
+ "listxattrRequest\032!.xtreemfs.pbrpc.listxa"
+ "ttrResponse\"\007\215\265\030\007\000\000\000\022Q\n\005mkdir\022\034.xtreemfs"
+ ".pbrpc.mkdirRequest\032!.xtreemfs.pbrpc.tim"
+ "estampResponse\"\007\215\265\030\010\000\000\000\022J\n\004open\022\033.xtreem"
+ "fs.pbrpc.openRequest\032\034.xtreemfs.pbrpc.op"
+ "enResponse\"\007\215\265\030\t\000\000\000\022T\n\007readdir\022\036.xtreemf"
+ "s.pbrpc.readdirRequest\032 .xtreemfs.pbrpc."
+ "DirectoryEntries\"\007\215\265\030\n\000\000\000\022V\n\010readlink\022\037."
+ "xtreemfs.pbrpc.readlinkRequest\032 .xtreemf"
+ "s.pbrpc.readlinkResponse\"\007\215\265\030\013\000\000\000\022]\n\013rem"
+ "ovexattr\022\".xtreemfs.pbrpc.removexattrReq"
+ "uest\032!.xtreemfs.pbrpc.timestampResponse\""
+ "\007\215\265\030\014\000\000\000\022P\n\006rename\022\035.xtreemfs.pbrpc.rena"
+ "meRequest\032\036.xtreemfs.pbrpc.renameRespons"
+ "e\"\007\215\265\030\r\000\000\000\022Q\n\005rmdir\022\034.xtreemfs.pbrpc.rmd"
+ "irRequest\032!.xtreemfs.pbrpc.timestampResp"
+ "onse\"\007\215\265\030\016\000\000\000\022U\n\007setattr\022\036.xtreemfs.pbrp"
+ "c.setattrRequest\032!.xtreemfs.pbrpc.timest"
+ "ampResponse\"\007\215\265\030\017\000\000\000\022W\n\010setxattr\022\037.xtree"
+ "mfs.pbrpc.setxattrRequest\032!.xtreemfs.pbr"
+ "pc.timestampResponse\"\007\215\265\030\020\000\000\000\022K\n\007statvfs"
+ "\022\036.xtreemfs.pbrpc.statvfsRequest\032\027.xtree"
+ "mfs.pbrpc.StatVFS\"\007\215\265\030\021\000\000\000\022U\n\007symlink\022\036."
+ "xtreemfs.pbrpc.symlinkRequest\032!.xtreemfs"
+ ".pbrpc.timestampResponse\"\007\215\265\030\022\000\000\000\022P\n\006unl"
+ "ink\022\035.xtreemfs.pbrpc.unlinkRequest\032\036.xtr"
+ "eemfs.pbrpc.unlinkResponse\"\007\215\265\030\023\000\000\000\022O\n\006a"
+ "ccess\022\035.xtreemfs.pbrpc.accessRequest\032\035.x"
+ "treemfs.pbrpc.emptyResponse\"\007\215\265\030\024\000\000\000\022[\n\023"
+ "xtreemfs_checkpoint\022\034.xtreemfs.pbrpc.emp"
+ "tyRequest\032\035.xtreemfs.pbrpc.emptyResponse"
+ "\"\007\215\265\030\036\000\000\000\022\214\001\n\032xtreemfs_check_file_exists"
+ "\0221.xtreemfs.pbrpc.xtreemfs_check_file_ex"
+ "istsRequest\0322.xtreemfs.pbrpc.xtreemfs_ch"
+ "eck_file_existsResponse\"\007\215\265\030\037\000\000\000\022w\n\026xtre"
+ "emfs_dump_database\0225.xtreemfs.pbrpc.xtre"
+ "emfs_dump_restore_databaseRequest\032\035.xtre"
+ "emfs.pbrpc.emptyResponse\"\007\215\265\030 \000\000\000\022\214\001\n\032xt"
+ "reemfs_get_suitable_osds\0221.xtreemfs.pbrp"
+ "c.xtreemfs_get_suitable_osdsRequest\0322.xt"
+ "reemfs.pbrpc.xtreemfs_get_suitable_osdsR"
+ "esponse\"\007\215\265\030!\000\000\000\022`\n\027xtreemfs_internal_de"
+ "bug\022\035.xtreemfs.pbrpc.stringMessage\032\035.xtr"
+ "eemfs.pbrpc.stringMessage\"\007\215\265\030\"\000\000\000\022n\n\020xt"
+ "reemfs_listdir\022\'.xtreemfs.pbrpc.xtreemfs"
+ "_listdirRequest\032(.xtreemfs.pbrpc.xtreemf"
+ "s_listdirResponse\"\007\215\265\030#\000\000\000\022P\n\016xtreemfs_l"
+ "svol\022\034.xtreemfs.pbrpc.emptyRequest\032\027.xtr"
+ "eemfs.pbrpc.Volumes\"\007\215\265\030$\000\000\000\022P\n\016xtreemfs"
+ "_mkvol\022\026.xtreemfs.pbrpc.Volume\032\035.xtreemf"
+ "s.pbrpc.emptyResponse\"\007\215\265\030/\000\000\000\022P\n\031xtreem"
+ "fs_renew_capability\022\024.xtreemfs.pbrpc.XCa"
+ "p\032\024.xtreemfs.pbrpc.XCap\"\007\215\265\030%\000\000\000\022f\n\036xtre"
+ "emfs_replication_to_master\022\034.xtreemfs.pb"
+ "rpc.emptyRequest\032\035.xtreemfs.pbrpc.emptyR"
+ "esponse\"\007\215\265\030&\000\000\000\022k\n\024xtreemfs_replica_add"
+ "\022+.xtreemfs.pbrpc.xtreemfs_replica_addRe"
+ "quest\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265"
+ "\030\'\000\000\000\022h\n\025xtreemfs_replica_list\022,.xtreemf"
+ "s.pbrpc.xtreemfs_replica_listRequest\032\030.x"
+ "treemfs.pbrpc.Replicas\"\007\215\265\030(\000\000\000\022s\n\027xtree"
+ "mfs_replica_remove\022..xtreemfs.pbrpc.xtre"
+ "emfs_replica_removeRequest\032\037.xtreemfs.pb"
+ "rpc.FileCredentials\"\007\215\265\030)\000\000\000\022z\n\031xtreemfs"
+ "_restore_database\0225.xtreemfs.pbrpc.xtree"
+ "mfs_dump_restore_databaseRequest\032\035.xtree"
+ "mfs.pbrpc.emptyResponse\"\007\215\265\030*\000\000\000\022m\n\025xtre"
+ "emfs_restore_file\022,.xtreemfs.pbrpc.xtree"
+ "mfs_restore_fileRequest\032\035.xtreemfs.pbrpc"
+ ".emptyResponse\"\007\215\265\030+\000\000\000\022_\n\016xtreemfs_rmvo"
+ "l\022%.xtreemfs.pbrpc.xtreemfs_rmvolRequest"
+ "\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265\030,\000\000\000"
+ "\022Y\n\021xtreemfs_shutdown\022\034.xtreemfs.pbrpc.e"
+ "mptyRequest\032\035.xtreemfs.pbrpc.emptyRespon"
+ "se\"\007\215\265\030-\000\000\000\022y\n\031xtreemfs_update_file_size"
+ "\0220.xtreemfs.pbrpc.xtreemfs_update_file_s"
+ "izeRequest\032!.xtreemfs.pbrpc.timestampRes"
+ "ponse\"\007\215\265\030.\000\000\000\022\244\001\n\"xtreemfs_set_replica_"
+ "update_policy\0229.xtreemfs.pbrpc.xtreemfs_"
+ "set_replica_update_policyRequest\032:.xtree"
+ "mfs.pbrpc.xtreemfs_set_replica_update_po"
+ "licyResponse\"\007\215\265\0300\000\000\000\022\222\001\n\034xtreemfs_set_r"
+ "ead_only_xattr\0223.xtreemfs.pbrpc.xtreemfs"
+ "_set_read_only_xattrRequest\0324.xtreemfs.p"
+ "brpc.xtreemfs_set_read_only_xattrRespons"
+ "e\"\007\215\265\0301\000\000\000\022\177\n\035xtreemfs_get_file_credenti"
+ "als\0224.xtreemfs.pbrpc.xtreemfs_get_file_c"
+ "redentialsRequest\032\037.xtreemfs.pbrpc.FileC"
+ "redentials\"\007\215\265\0302\000\000\000\032\007\225\265\030!N\000\000B(\n&org.xtre"
+ "emfs.pbrpc.generatedinterfaces", 9190);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"xtreemfs/MRC.proto", &protobuf_RegisterTypes);
Stat::default_instance_ = new Stat();
@@ -1652,7 +1658,6 @@ struct 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_;
@@ -1706,8 +1711,6 @@ bool ACCESS_FLAGS_IsValid(int value) {
// ===================================================================
-const ::std::string Stat::_default_user_id_;
-const ::std::string Stat::_default_group_id_;
#ifndef _MSC_VER
const int Stat::kDevFieldNumber;
const int Stat::kInoFieldNumber;
@@ -1745,8 +1748,8 @@ void Stat::SharedCtor() {
ino_ = GOOGLE_ULONGLONG(0);
mode_ = 0u;
nlink_ = 0u;
- user_id_ = const_cast< ::std::string*>(&_default_user_id_);
- group_id_ = const_cast< ::std::string*>(&_default_group_id_);
+ 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);
@@ -1763,10 +1766,10 @@ Stat::~Stat() {
}
void Stat::SharedDtor() {
- if (user_id_ != &_default_user_id_) {
+ if (user_id_ != &::google::protobuf::internal::kEmptyString) {
delete user_id_;
}
- if (group_id_ != &_default_group_id_) {
+ if (group_id_ != &::google::protobuf::internal::kEmptyString) {
delete group_id_;
}
if (this != default_instance_) {
@@ -1784,7 +1787,8 @@ const ::google::protobuf::Descriptor* Stat::descriptor() {
}
const Stat& Stat::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
Stat* Stat::default_instance_ = NULL;
@@ -1799,13 +1803,13 @@ void Stat::Clear() {
ino_ = GOOGLE_ULONGLONG(0);
mode_ = 0u;
nlink_ = 0u;
- if (_has_bit(4)) {
- if (user_id_ != &_default_user_id_) {
+ if (has_user_id()) {
+ if (user_id_ != &::google::protobuf::internal::kEmptyString) {
user_id_->clear();
}
}
- if (_has_bit(5)) {
- if (group_id_ != &_default_group_id_) {
+ if (has_group_id()) {
+ if (group_id_ != &::google::protobuf::internal::kEmptyString) {
group_id_->clear();
}
}
@@ -1837,14 +1841,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &dev_)));
- _set_bit(0);
+ 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) ==
@@ -1853,14 +1857,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &ino_)));
- _set_bit(1);
+ 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) ==
@@ -1869,14 +1873,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &mode_)));
- _set_bit(2);
+ 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) ==
@@ -1885,14 +1889,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &nlink_)));
- _set_bit(3);
+ 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) ==
@@ -1909,7 +1913,7 @@ bool Stat::MergePartialFromCodedStream(
if (input->ExpectTag(50)) goto parse_group_id;
break;
}
-
+
// required string group_id = 6;
case 6: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1926,7 +1930,7 @@ bool Stat::MergePartialFromCodedStream(
if (input->ExpectTag(57)) goto parse_size;
break;
}
-
+
// required fixed64 size = 7;
case 7: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1935,14 +1939,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &size_)));
- _set_bit(6);
+ 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) ==
@@ -1951,14 +1955,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &atime_ns_)));
- _set_bit(7);
+ 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) ==
@@ -1967,14 +1971,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &mtime_ns_)));
- _set_bit(8);
+ 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) ==
@@ -1983,14 +1987,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &ctime_ns_)));
- _set_bit(9);
+ 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) ==
@@ -1999,14 +2003,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &blksize_)));
- _set_bit(10);
+ 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) ==
@@ -2015,14 +2019,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &etag_)));
- _set_bit(11);
+ 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) ==
@@ -2031,14 +2035,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &truncate_epoch_)));
- _set_bit(12);
+ 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) ==
@@ -2047,14 +2051,14 @@ bool Stat::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &attributes_)));
- _set_bit(13);
+ set_has_attributes();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2074,83 +2078,83 @@ bool Stat::MergePartialFromCodedStream(
void Stat::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed64 dev = 1;
- if (_has_bit(0)) {
+ if (has_dev()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->dev(), output);
}
-
+
// required fixed64 ino = 2;
- if (_has_bit(1)) {
+ if (has_ino()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->ino(), output);
}
-
+
// required fixed32 mode = 3;
- if (_has_bit(2)) {
+ if (has_mode()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->mode(), output);
}
-
+
// required fixed32 nlink = 4;
- if (_has_bit(3)) {
+ if (has_nlink()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->nlink(), output);
}
-
+
// required string user_id = 5;
- if (_has_bit(4)) {
+ 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_bit(5)) {
+ 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_bit(6)) {
+ if (has_size()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(7, this->size(), output);
}
-
+
// required fixed64 atime_ns = 8;
- if (_has_bit(7)) {
+ if (has_atime_ns()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(8, this->atime_ns(), output);
}
-
+
// required fixed64 mtime_ns = 9;
- if (_has_bit(8)) {
+ if (has_mtime_ns()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(9, this->mtime_ns(), output);
}
-
+
// required fixed64 ctime_ns = 10;
- if (_has_bit(9)) {
+ if (has_ctime_ns()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(10, this->ctime_ns(), output);
}
-
+
// required fixed32 blksize = 11;
- if (_has_bit(10)) {
+ if (has_blksize()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->blksize(), output);
}
-
+
// optional fixed64 etag = 12;
- if (_has_bit(11)) {
+ if (has_etag()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(12, this->etag(), output);
}
-
+
// required fixed32 truncate_epoch = 13;
- if (_has_bit(12)) {
+ if (has_truncate_epoch()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(13, this->truncate_epoch(), output);
}
-
+
// optional fixed32 attributes = 14;
- if (_has_bit(13)) {
+ if (has_attributes()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(14, this->attributes(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -2160,27 +2164,27 @@ void Stat::SerializeWithCachedSizes(
::google::protobuf::uint8* Stat::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed64 dev = 1;
- if (_has_bit(0)) {
+ if (has_dev()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->dev(), target);
}
-
+
// required fixed64 ino = 2;
- if (_has_bit(1)) {
+ if (has_ino()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->ino(), target);
}
-
+
// required fixed32 mode = 3;
- if (_has_bit(2)) {
+ if (has_mode()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->mode(), target);
}
-
+
// required fixed32 nlink = 4;
- if (_has_bit(3)) {
+ if (has_nlink()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->nlink(), target);
}
-
+
// required string user_id = 5;
- if (_has_bit(4)) {
+ if (has_user_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->user_id().data(), this->user_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2188,9 +2192,9 @@ void Stat::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
5, this->user_id(), target);
}
-
+
// required string group_id = 6;
- if (_has_bit(5)) {
+ if (has_group_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->group_id().data(), this->group_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2198,47 +2202,47 @@ void Stat::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6, this->group_id(), target);
}
-
+
// required fixed64 size = 7;
- if (_has_bit(6)) {
+ if (has_size()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(7, this->size(), target);
}
-
+
// required fixed64 atime_ns = 8;
- if (_has_bit(7)) {
+ if (has_atime_ns()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(8, this->atime_ns(), target);
}
-
+
// required fixed64 mtime_ns = 9;
- if (_has_bit(8)) {
+ if (has_mtime_ns()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(9, this->mtime_ns(), target);
}
-
+
// required fixed64 ctime_ns = 10;
- if (_has_bit(9)) {
+ if (has_ctime_ns()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(10, this->ctime_ns(), target);
}
-
+
// required fixed32 blksize = 11;
- if (_has_bit(10)) {
+ if (has_blksize()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->blksize(), target);
}
-
+
// optional fixed64 etag = 12;
- if (_has_bit(11)) {
+ if (has_etag()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(12, this->etag(), target);
}
-
+
// required fixed32 truncate_epoch = 13;
- if (_has_bit(12)) {
+ if (has_truncate_epoch()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(13, this->truncate_epoch(), target);
}
-
+
// optional fixed32 attributes = 14;
- if (_has_bit(13)) {
+ 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);
@@ -2248,84 +2252,84 @@ void Stat::SerializeWithCachedSizes(
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 +=
@@ -2353,48 +2357,48 @@ void Stat::MergeFrom(const ::google::protobuf::Message& from) {
void Stat::MergeFrom(const Stat& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_dev()) {
set_dev(from.dev());
}
- if (from._has_bit(1)) {
+ if (from.has_ino()) {
set_ino(from.ino());
}
- if (from._has_bit(2)) {
+ if (from.has_mode()) {
set_mode(from.mode());
}
- if (from._has_bit(3)) {
+ if (from.has_nlink()) {
set_nlink(from.nlink());
}
- if (from._has_bit(4)) {
+ if (from.has_user_id()) {
set_user_id(from.user_id());
}
- if (from._has_bit(5)) {
+ if (from.has_group_id()) {
set_group_id(from.group_id());
}
- if (from._has_bit(6)) {
+ if (from.has_size()) {
set_size(from.size());
}
- if (from._has_bit(7)) {
+ if (from.has_atime_ns()) {
set_atime_ns(from.atime_ns());
}
}
if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
- if (from._has_bit(8)) {
+ if (from.has_mtime_ns()) {
set_mtime_ns(from.mtime_ns());
}
- if (from._has_bit(9)) {
+ if (from.has_ctime_ns()) {
set_ctime_ns(from.ctime_ns());
}
- if (from._has_bit(10)) {
+ if (from.has_blksize()) {
set_blksize(from.blksize());
}
- if (from._has_bit(11)) {
+ if (from.has_etag()) {
set_etag(from.etag());
}
- if (from._has_bit(12)) {
+ if (from.has_truncate_epoch()) {
set_truncate_epoch(from.truncate_epoch());
}
- if (from._has_bit(13)) {
+ if (from.has_attributes()) {
set_attributes(from.attributes());
}
}
@@ -2415,7 +2419,7 @@ void Stat::CopyFrom(const Stat& from) {
bool Stat::IsInitialized() const {
if ((_has_bits_[0] & 0x000017ff) != 0x000017ff) return false;
-
+
return true;
}
@@ -2452,7 +2456,6 @@ void Stat::Swap(Stat* other) {
// ===================================================================
-const ::std::string DirectoryEntry::_default_name_;
#ifndef _MSC_VER
const int DirectoryEntry::kNameFieldNumber;
const int DirectoryEntry::kStbufFieldNumber;
@@ -2475,7 +2478,7 @@ DirectoryEntry::DirectoryEntry(const DirectoryEntry& from)
void DirectoryEntry::SharedCtor() {
_cached_size_ = 0;
- name_ = const_cast< ::std::string*>(&_default_name_);
+ name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
stbuf_ = NULL;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -2485,7 +2488,7 @@ DirectoryEntry::~DirectoryEntry() {
}
void DirectoryEntry::SharedDtor() {
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
if (this != default_instance_) {
@@ -2504,7 +2507,8 @@ const ::google::protobuf::Descriptor* DirectoryEntry::descriptor() {
}
const DirectoryEntry& DirectoryEntry::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
DirectoryEntry* DirectoryEntry::default_instance_ = NULL;
@@ -2515,12 +2519,12 @@ DirectoryEntry* DirectoryEntry::New() const {
void DirectoryEntry::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
- if (_has_bit(1)) {
+ if (has_stbuf()) {
if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear();
}
}
@@ -2549,7 +2553,7 @@ bool DirectoryEntry::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_stbuf;
break;
}
-
+
// optional .xtreemfs.pbrpc.Stat stbuf = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2563,7 +2567,7 @@ bool DirectoryEntry::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2583,20 +2587,20 @@ bool DirectoryEntry::MergePartialFromCodedStream(
void DirectoryEntry::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string name = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_stbuf()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->stbuf(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -2606,7 +2610,7 @@ void DirectoryEntry::SerializeWithCachedSizes(
::google::protobuf::uint8* DirectoryEntry::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string name = 1;
- if (_has_bit(0)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -2614,14 +2618,14 @@ void DirectoryEntry::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->name(), target);
}
-
+
// optional .xtreemfs.pbrpc.Stat stbuf = 2;
- if (_has_bit(1)) {
+ 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);
@@ -2631,7 +2635,7 @@ void DirectoryEntry::SerializeWithCachedSizes(
int DirectoryEntry::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string name = 1;
if (has_name()) {
@@ -2639,14 +2643,14 @@ int DirectoryEntry::ByteSize() const {
::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 +=
@@ -2674,10 +2678,10 @@ void DirectoryEntry::MergeFrom(const ::google::protobuf::Message& from) {
void DirectoryEntry::MergeFrom(const DirectoryEntry& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_name()) {
set_name(from.name());
}
- if (from._has_bit(1)) {
+ if (from.has_stbuf()) {
mutable_stbuf()->::xtreemfs::pbrpc::Stat::MergeFrom(from.stbuf());
}
}
@@ -2698,7 +2702,7 @@ void DirectoryEntry::CopyFrom(const DirectoryEntry& from) {
bool DirectoryEntry::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
if (has_stbuf()) {
if (!this->stbuf().IsInitialized()) return false;
}
@@ -2769,7 +2773,8 @@ const ::google::protobuf::Descriptor* DirectoryEntries::descriptor() {
}
const DirectoryEntries& DirectoryEntries::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
DirectoryEntries* DirectoryEntries::default_instance_ = NULL;
@@ -2804,7 +2809,7 @@ bool DirectoryEntries::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2828,7 +2833,7 @@ void DirectoryEntries::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->entries(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -2843,7 +2848,7 @@ void DirectoryEntries::SerializeWithCachedSizes(
WriteMessageNoVirtualToArray(
1, this->entries(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -2853,7 +2858,7 @@ void DirectoryEntries::SerializeWithCachedSizes(
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++) {
@@ -2861,7 +2866,7 @@ int DirectoryEntries::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->entries(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2904,7 +2909,7 @@ void DirectoryEntries::CopyFrom(const DirectoryEntries& from) {
}
bool DirectoryEntries::IsInitialized() const {
-
+
for (int i = 0; i < entries_size(); i++) {
if (!this->entries(i).IsInitialized()) return false;
}
@@ -2931,13 +2936,10 @@ void DirectoryEntries::Swap(DirectoryEntries* other) {
// ===================================================================
-const ::std::string XAttr::_default_name_;
-const ::std::string XAttr::_default_value_;
-const ::std::string XAttr::_default_value_bytes_;
#ifndef _MSC_VER
const int XAttr::kNameFieldNumber;
const int XAttr::kValueFieldNumber;
-const int XAttr::kValueBytesFieldNumber;
+const int XAttr::kValueBytesStringFieldNumber;
#endif // !_MSC_VER
XAttr::XAttr()
@@ -2956,9 +2958,9 @@ XAttr::XAttr(const XAttr& from)
void XAttr::SharedCtor() {
_cached_size_ = 0;
- name_ = const_cast< ::std::string*>(&_default_name_);
- value_ = const_cast< ::std::string*>(&_default_value_);
- value_bytes_ = const_cast< ::std::string*>(&_default_value_bytes_);
+ 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_));
}
@@ -2967,14 +2969,14 @@ XAttr::~XAttr() {
}
void XAttr::SharedDtor() {
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
- if (value_ != &_default_value_) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
delete value_;
}
- if (value_bytes_ != &_default_value_bytes_) {
- delete value_bytes_;
+ if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) {
+ delete value_bytes_string_;
}
if (this != default_instance_) {
}
@@ -2991,7 +2993,8 @@ const ::google::protobuf::Descriptor* XAttr::descriptor() {
}
const XAttr& XAttr::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
XAttr* XAttr::default_instance_ = NULL;
@@ -3002,19 +3005,19 @@ XAttr* XAttr::New() const {
void XAttr::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
- if (_has_bit(1)) {
- if (value_ != &_default_value_) {
+ if (has_value()) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
value_->clear();
}
}
- if (_has_bit(2)) {
- if (value_bytes_ != &_default_value_bytes_) {
- value_bytes_->clear();
+ if (has_value_bytes_string()) {
+ if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) {
+ value_bytes_string_->clear();
}
}
}
@@ -3043,7 +3046,7 @@ bool XAttr::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_value;
break;
}
-
+
// optional string value = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3057,24 +3060,24 @@ bool XAttr::MergePartialFromCodedStream(
} else {
goto handle_uninterpreted;
}
- if (input->ExpectTag(26)) goto parse_value_bytes;
+ if (input->ExpectTag(26)) goto parse_value_bytes_string;
break;
}
-
- // optional bytes value_bytes = 3;
+
+ // 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:
+ parse_value_bytes_string:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
- input, this->mutable_value_bytes()));
+ 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) ==
@@ -3094,29 +3097,29 @@ bool XAttr::MergePartialFromCodedStream(
void XAttr::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->value(), output);
}
-
- // optional bytes value_bytes = 3;
- if (_has_bit(2)) {
+
+ // optional bytes value_bytes_string = 3;
+ if (has_value_bytes_string()) {
::google::protobuf::internal::WireFormatLite::WriteBytes(
- 3, this->value_bytes(), output);
+ 3, this->value_bytes_string(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -3126,7 +3129,7 @@ void XAttr::SerializeWithCachedSizes(
::google::protobuf::uint8* XAttr::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string name = 1;
- if (_has_bit(0)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -3134,9 +3137,9 @@ void XAttr::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->name(), target);
}
-
+
// optional string value = 2;
- if (_has_bit(1)) {
+ if (has_value()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->value().data(), this->value().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -3144,14 +3147,14 @@ void XAttr::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->value(), target);
}
-
- // optional bytes value_bytes = 3;
- if (_has_bit(2)) {
+
+ // optional bytes value_bytes_string = 3;
+ if (has_value_bytes_string()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
- 3, this->value_bytes(), target);
+ 3, this->value_bytes_string(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -3161,7 +3164,7 @@ void XAttr::SerializeWithCachedSizes(
int XAttr::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string name = 1;
if (has_name()) {
@@ -3169,21 +3172,21 @@ int XAttr::ByteSize() const {
::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 = 3;
- if (has_value_bytes()) {
+
+ // optional bytes value_bytes_string = 3;
+ if (has_value_bytes_string()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
- this->value_bytes());
+ this->value_bytes_string());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -3211,14 +3214,14 @@ void XAttr::MergeFrom(const ::google::protobuf::Message& from) {
void XAttr::MergeFrom(const XAttr& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_name()) {
set_name(from.name());
}
- if (from._has_bit(1)) {
+ if (from.has_value()) {
set_value(from.value());
}
- if (from._has_bit(2)) {
- set_value_bytes(from.value_bytes());
+ if (from.has_value_bytes_string()) {
+ set_value_bytes_string(from.value_bytes_string());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
@@ -3238,7 +3241,7 @@ void XAttr::CopyFrom(const XAttr& from) {
bool XAttr::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -3246,7 +3249,7 @@ void XAttr::Swap(XAttr* other) {
if (other != this) {
std::swap(name_, other->name_);
std::swap(value_, other->value_);
- std::swap(value_bytes_, other->value_bytes_);
+ 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_);
@@ -3264,10 +3267,6 @@ void XAttr::Swap(XAttr* other) {
// ===================================================================
-const ::std::string Volume::_default_id_;
-const ::std::string Volume::_default_name_;
-const ::std::string Volume::_default_owner_group_id_;
-const ::std::string Volume::_default_owner_user_id_;
#ifndef _MSC_VER
const int Volume::kAccessControlPolicyFieldNumber;
const int Volume::kDefaultStripingPolicyFieldNumber;
@@ -3298,11 +3297,11 @@ void Volume::SharedCtor() {
_cached_size_ = 0;
access_control_policy_ = 1;
default_striping_policy_ = NULL;
- id_ = const_cast< ::std::string*>(&_default_id_);
+ id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
mode_ = 0u;
- name_ = const_cast< ::std::string*>(&_default_name_);
- owner_group_id_ = const_cast< ::std::string*>(&_default_owner_group_id_);
- owner_user_id_ = const_cast< ::std::string*>(&_default_owner_user_id_);
+ 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_));
}
@@ -3311,16 +3310,16 @@ Volume::~Volume() {
}
void Volume::SharedDtor() {
- if (id_ != &_default_id_) {
+ if (id_ != &::google::protobuf::internal::kEmptyString) {
delete id_;
}
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
- if (owner_group_id_ != &_default_owner_group_id_) {
+ if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) {
delete owner_group_id_;
}
- if (owner_user_id_ != &_default_owner_user_id_) {
+ if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) {
delete owner_user_id_;
}
if (this != default_instance_) {
@@ -3339,7 +3338,8 @@ const ::google::protobuf::Descriptor* Volume::descriptor() {
}
const Volume& Volume::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
Volume* Volume::default_instance_ = NULL;
@@ -3351,27 +3351,27 @@ Volume* Volume::New() const {
void Volume::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
access_control_policy_ = 1;
- if (_has_bit(1)) {
+ if (has_default_striping_policy()) {
if (default_striping_policy_ != NULL) default_striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear();
}
- if (_has_bit(2)) {
- if (id_ != &_default_id_) {
+ if (has_id()) {
+ if (id_ != &::google::protobuf::internal::kEmptyString) {
id_->clear();
}
}
mode_ = 0u;
- if (_has_bit(4)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
- if (_has_bit(5)) {
- if (owner_group_id_ != &_default_owner_group_id_) {
+ if (has_owner_group_id()) {
+ if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) {
owner_group_id_->clear();
}
}
- if (_has_bit(6)) {
- if (owner_user_id_ != &_default_owner_user_id_) {
+ if (has_owner_user_id()) {
+ if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) {
owner_user_id_->clear();
}
}
@@ -3395,8 +3395,8 @@ bool Volume::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::AccessControlPolicyType_IsValid(value)) {
+ set_access_control_policy(static_cast< ::xtreemfs::pbrpc::AccessControlPolicyType >(value));
} else {
mutable_unknown_fields()->AddVarint(1, value);
}
@@ -3406,7 +3406,7 @@ bool Volume::MergePartialFromCodedStream(
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) ==
@@ -3420,7 +3420,7 @@ bool Volume::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_id;
break;
}
-
+
// required string id = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3437,7 +3437,7 @@ bool Volume::MergePartialFromCodedStream(
if (input->ExpectTag(37)) goto parse_mode;
break;
}
-
+
// required fixed32 mode = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3446,14 +3446,14 @@ bool Volume::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &mode_)));
- _set_bit(3);
+ 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) ==
@@ -3470,7 +3470,7 @@ bool Volume::MergePartialFromCodedStream(
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) ==
@@ -3487,7 +3487,7 @@ bool Volume::MergePartialFromCodedStream(
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) ==
@@ -3504,7 +3504,7 @@ bool Volume::MergePartialFromCodedStream(
if (input->ExpectTag(66)) goto parse_attrs;
break;
}
-
+
// repeated .xtreemfs.pbrpc.KeyValuePair attrs = 8;
case 8: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3519,7 +3519,7 @@ bool Volume::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3539,64 +3539,64 @@ bool Volume::MergePartialFromCodedStream(
void Volume::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_default_striping_policy()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->default_striping_policy(), output);
}
-
+
// required string id = 3;
- if (_has_bit(2)) {
+ 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_bit(3)) {
+ if (has_mode()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->mode(), output);
}
-
+
// required string name = 5;
- if (_has_bit(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(
5, this->name(), output);
}
-
+
// required string owner_group_id = 6;
- if (_has_bit(5)) {
+ 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_bit(6)) {
+ 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);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -3606,20 +3606,20 @@ void Volume::SerializeWithCachedSizes(
::google::protobuf::uint8* Volume::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_default_striping_policy()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
2, this->default_striping_policy(), target);
}
-
+
// required string id = 3;
- if (_has_bit(2)) {
+ if (has_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->id().data(), this->id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -3627,14 +3627,14 @@ void Volume::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->id(), target);
}
-
+
// required fixed32 mode = 4;
- if (_has_bit(3)) {
+ if (has_mode()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->mode(), target);
}
-
+
// required string name = 5;
- if (_has_bit(4)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -3642,9 +3642,9 @@ void Volume::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
5, this->name(), target);
}
-
+
// required string owner_group_id = 6;
- if (_has_bit(5)) {
+ 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);
@@ -3652,9 +3652,9 @@ void Volume::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6, this->owner_group_id(), target);
}
-
+
// required string owner_user_id = 7;
- if (_has_bit(6)) {
+ 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);
@@ -3662,14 +3662,14 @@ void Volume::SerializeWithCachedSizes(
::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);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -3679,54 +3679,54 @@ void Volume::SerializeWithCachedSizes(
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());
}
-
+
}
// repeated .xtreemfs.pbrpc.KeyValuePair attrs = 8;
total_size += 1 * this->attrs_size();
@@ -3735,7 +3735,7 @@ int Volume::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->attrs(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -3763,25 +3763,25 @@ 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_bit(0)) {
+ if (from.has_access_control_policy()) {
set_access_control_policy(from.access_control_policy());
}
- if (from._has_bit(1)) {
+ if (from.has_default_striping_policy()) {
mutable_default_striping_policy()->::xtreemfs::pbrpc::StripingPolicy::MergeFrom(from.default_striping_policy());
}
- if (from._has_bit(2)) {
+ if (from.has_id()) {
set_id(from.id());
}
- if (from._has_bit(3)) {
+ if (from.has_mode()) {
set_mode(from.mode());
}
- if (from._has_bit(4)) {
+ if (from.has_name()) {
set_name(from.name());
}
- if (from._has_bit(5)) {
+ if (from.has_owner_group_id()) {
set_owner_group_id(from.owner_group_id());
}
- if (from._has_bit(6)) {
+ if (from.has_owner_user_id()) {
set_owner_user_id(from.owner_user_id());
}
}
@@ -3802,7 +3802,7 @@ void Volume::CopyFrom(const Volume& 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;
}
@@ -3882,7 +3882,8 @@ const ::google::protobuf::Descriptor* Volumes::descriptor() {
}
const Volumes& Volumes::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
Volumes* Volumes::default_instance_ = NULL;
@@ -3917,7 +3918,7 @@ bool Volumes::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -3941,7 +3942,7 @@ void Volumes::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->volumes(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -3956,7 +3957,7 @@ void Volumes::SerializeWithCachedSizes(
WriteMessageNoVirtualToArray(
1, this->volumes(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -3966,7 +3967,7 @@ void Volumes::SerializeWithCachedSizes(
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++) {
@@ -3974,7 +3975,7 @@ int Volumes::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->volumes(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -4017,7 +4018,7 @@ void Volumes::CopyFrom(const Volumes& from) {
}
bool Volumes::IsInitialized() const {
-
+
for (int i = 0; i < volumes_size(); i++) {
if (!this->volumes(i).IsInitialized()) return false;
}
@@ -4044,13 +4045,10 @@ void Volumes::Swap(Volumes* other) {
// ===================================================================
-const ::std::string StatVFS::_default_fsid_;
-const ::std::string StatVFS::_default_name_;
-const ::std::string StatVFS::_default_owner_group_id_;
-const ::std::string StatVFS::_default_owner_user_id_;
#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;
@@ -4082,16 +4080,17 @@ 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*>(&_default_fsid_);
+ 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*>(&_default_name_);
- owner_group_id_ = const_cast< ::std::string*>(&_default_owner_group_id_);
- owner_user_id_ = const_cast< ::std::string*>(&_default_owner_user_id_);
+ 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_));
}
@@ -4100,16 +4099,16 @@ StatVFS::~StatVFS() {
}
void StatVFS::SharedDtor() {
- if (fsid_ != &_default_fsid_) {
+ if (fsid_ != &::google::protobuf::internal::kEmptyString) {
delete fsid_;
}
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
- if (owner_group_id_ != &_default_owner_group_id_) {
+ if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) {
delete owner_group_id_;
}
- if (owner_user_id_ != &_default_owner_user_id_) {
+ if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) {
delete owner_user_id_;
}
if (this != default_instance_) {
@@ -4128,7 +4127,8 @@ const ::google::protobuf::Descriptor* StatVFS::descriptor() {
}
const StatVFS& StatVFS::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
StatVFS* StatVFS::default_instance_ = NULL;
@@ -4141,33 +4141,34 @@ 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_bit(3)) {
- if (fsid_ != &_default_fsid_) {
+ if (has_fsid()) {
+ if (fsid_ != &::google::protobuf::internal::kEmptyString) {
fsid_->clear();
}
}
namemax_ = 0u;
access_control_policy_ = 1;
- if (_has_bit(6)) {
+ if (has_default_striping_policy()) {
if (default_striping_policy_ != NULL) default_striping_policy_->::xtreemfs::pbrpc::StripingPolicy::Clear();
}
- etag_ = GOOGLE_ULONGLONG(0);
}
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+ etag_ = GOOGLE_ULONGLONG(0);
mode_ = 0u;
- if (_has_bit(9)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
- if (_has_bit(10)) {
- if (owner_group_id_ != &_default_owner_group_id_) {
+ if (has_owner_group_id()) {
+ if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) {
owner_group_id_->clear();
}
}
- if (_has_bit(11)) {
- if (owner_user_id_ != &_default_owner_user_id_) {
+ if (has_owner_user_id()) {
+ if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) {
owner_user_id_->clear();
}
}
@@ -4189,14 +4190,14 @@ bool StatVFS::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &bsize_)));
- _set_bit(0);
+ 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) ==
@@ -4205,14 +4206,14 @@ bool StatVFS::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &bavail_)));
- _set_bit(1);
+ 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) ==
@@ -4221,14 +4222,14 @@ bool StatVFS::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &blocks_)));
- _set_bit(2);
+ 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) ==
@@ -4245,7 +4246,7 @@ bool StatVFS::MergePartialFromCodedStream(
if (input->ExpectTag(45)) goto parse_namemax;
break;
}
-
+
// required fixed32 namemax = 5;
case 5: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -4254,14 +4255,14 @@ bool StatVFS::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &namemax_)));
- _set_bit(4);
+ 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) ==
@@ -4271,8 +4272,8 @@ bool StatVFS::MergePartialFromCodedStream(
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));
+ if (::xtreemfs::pbrpc::AccessControlPolicyType_IsValid(value)) {
+ set_access_control_policy(static_cast< ::xtreemfs::pbrpc::AccessControlPolicyType >(value));
} else {
mutable_unknown_fields()->AddVarint(6, value);
}
@@ -4282,7 +4283,7 @@ bool StatVFS::MergePartialFromCodedStream(
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) ==
@@ -4296,7 +4297,7 @@ bool StatVFS::MergePartialFromCodedStream(
if (input->ExpectTag(65)) goto parse_etag;
break;
}
-
+
// required fixed64 etag = 8;
case 8: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -4305,14 +4306,14 @@ bool StatVFS::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &etag_)));
- _set_bit(7);
+ 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) ==
@@ -4321,14 +4322,14 @@ bool StatVFS::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &mode_)));
- _set_bit(8);
+ 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) ==
@@ -4345,7 +4346,7 @@ bool StatVFS::MergePartialFromCodedStream(
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) ==
@@ -4362,7 +4363,7 @@ bool StatVFS::MergePartialFromCodedStream(
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) ==
@@ -4376,10 +4377,26 @@ bool StatVFS::MergePartialFromCodedStream(
} 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) ==
@@ -4399,83 +4416,88 @@ bool StatVFS::MergePartialFromCodedStream(
void StatVFS::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed32 bsize = 1;
- if (_has_bit(0)) {
+ if (has_bsize()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->bsize(), output);
}
-
+
// required fixed64 bavail = 2;
- if (_has_bit(1)) {
+ if (has_bavail()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->bavail(), output);
}
-
+
// required fixed64 blocks = 3;
- if (_has_bit(2)) {
+ if (has_blocks()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->blocks(), output);
}
-
+
// required string fsid = 4;
- if (_has_bit(3)) {
+ 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_bit(4)) {
+ if (has_namemax()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->namemax(), output);
}
-
+
// required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6;
- if (_has_bit(5)) {
+ 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_bit(6)) {
+ if (has_default_striping_policy()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
7, this->default_striping_policy(), output);
}
-
+
// required fixed64 etag = 8;
- if (_has_bit(7)) {
+ if (has_etag()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(8, this->etag(), output);
}
-
+
// required fixed32 mode = 9;
- if (_has_bit(8)) {
+ if (has_mode()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(9, this->mode(), output);
}
-
+
// required string name = 10;
- if (_has_bit(9)) {
+ 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_bit(10)) {
+ 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_bit(11)) {
+ 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);
@@ -4485,22 +4507,22 @@ void StatVFS::SerializeWithCachedSizes(
::google::protobuf::uint8* StatVFS::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed32 bsize = 1;
- if (_has_bit(0)) {
+ if (has_bsize()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->bsize(), target);
}
-
+
// required fixed64 bavail = 2;
- if (_has_bit(1)) {
+ if (has_bavail()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->bavail(), target);
}
-
+
// required fixed64 blocks = 3;
- if (_has_bit(2)) {
+ if (has_blocks()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->blocks(), target);
}
-
+
// required string fsid = 4;
- if (_has_bit(3)) {
+ if (has_fsid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->fsid().data(), this->fsid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -4508,37 +4530,37 @@ void StatVFS::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->fsid(), target);
}
-
+
// required fixed32 namemax = 5;
- if (_has_bit(4)) {
+ if (has_namemax()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->namemax(), target);
}
-
+
// required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6;
- if (_has_bit(5)) {
+ 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_bit(6)) {
+ if (has_default_striping_policy()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
7, this->default_striping_policy(), target);
}
-
+
// required fixed64 etag = 8;
- if (_has_bit(7)) {
+ if (has_etag()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(8, this->etag(), target);
}
-
+
// required fixed32 mode = 9;
- if (_has_bit(8)) {
+ if (has_mode()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(9, this->mode(), target);
}
-
+
// required string name = 10;
- if (_has_bit(9)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -4546,9 +4568,9 @@ void StatVFS::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
10, this->name(), target);
}
-
+
// required string owner_group_id = 11;
- if (_has_bit(10)) {
+ 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);
@@ -4556,9 +4578,9 @@ void StatVFS::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
11, this->owner_group_id(), target);
}
-
+
// required string owner_user_id = 12;
- if (_has_bit(11)) {
+ 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);
@@ -4566,7 +4588,12 @@ void StatVFS::SerializeWithCachedSizes(
::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);
@@ -4576,81 +4603,86 @@ void StatVFS::SerializeWithCachedSizes(
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;
}
-
- }
- if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+
// 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 +=
@@ -4678,42 +4710,45 @@ void StatVFS::MergeFrom(const ::google::protobuf::Message& from) {
void StatVFS::MergeFrom(const StatVFS& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_bsize()) {
set_bsize(from.bsize());
}
- if (from._has_bit(1)) {
+ if (from.has_bavail()) {
set_bavail(from.bavail());
}
- if (from._has_bit(2)) {
+ if (from.has_bfree()) {
+ set_bfree(from.bfree());
+ }
+ if (from.has_blocks()) {
set_blocks(from.blocks());
}
- if (from._has_bit(3)) {
+ if (from.has_fsid()) {
set_fsid(from.fsid());
}
- if (from._has_bit(4)) {
+ if (from.has_namemax()) {
set_namemax(from.namemax());
}
- if (from._has_bit(5)) {
+ if (from.has_access_control_policy()) {
set_access_control_policy(from.access_control_policy());
}
- if (from._has_bit(6)) {
+ if (from.has_default_striping_policy()) {
mutable_default_striping_policy()->::xtreemfs::pbrpc::StripingPolicy::MergeFrom(from.default_striping_policy());
}
- if (from._has_bit(7)) {
- set_etag(from.etag());
- }
}
if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
- if (from._has_bit(8)) {
+ if (from.has_etag()) {
+ set_etag(from.etag());
+ }
+ if (from.has_mode()) {
set_mode(from.mode());
}
- if (from._has_bit(9)) {
+ if (from.has_name()) {
set_name(from.name());
}
- if (from._has_bit(10)) {
+ if (from.has_owner_group_id()) {
set_owner_group_id(from.owner_group_id());
}
- if (from._has_bit(11)) {
+ if (from.has_owner_user_id()) {
set_owner_user_id(from.owner_user_id());
}
}
@@ -4733,8 +4768,8 @@ void StatVFS::CopyFrom(const StatVFS& from) {
}
bool StatVFS::IsInitialized() const {
- if ((_has_bits_[0] & 0x00000fff) != 0x00000fff) return false;
-
+ if ((_has_bits_[0] & 0x00001ffb) != 0x00001ffb) return false;
+
if (has_default_striping_policy()) {
if (!this->default_striping_policy().IsInitialized()) return false;
}
@@ -4745,6 +4780,7 @@ 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_);
@@ -4824,7 +4860,8 @@ const ::google::protobuf::Descriptor* fsetattrRequest::descriptor() {
}
const fsetattrRequest& fsetattrRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
fsetattrRequest* fsetattrRequest::default_instance_ = NULL;
@@ -4835,11 +4872,11 @@ fsetattrRequest* fsetattrRequest::New() const {
void fsetattrRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_stbuf()) {
if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear();
}
to_set_ = 0u;
- if (_has_bit(2)) {
+ if (has_cap()) {
if (cap_ != NULL) cap_->::xtreemfs::pbrpc::XCap::Clear();
}
}
@@ -4865,7 +4902,7 @@ bool fsetattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(21)) goto parse_to_set;
break;
}
-
+
// required fixed32 to_set = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -4874,14 +4911,14 @@ bool fsetattrRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &to_set_)));
- _set_bit(1);
+ 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) ==
@@ -4895,7 +4932,7 @@ bool fsetattrRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -4915,22 +4952,22 @@ bool fsetattrRequest::MergePartialFromCodedStream(
void fsetattrRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.Stat stbuf = 1;
- if (_has_bit(0)) {
+ if (has_stbuf()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->stbuf(), output);
}
-
+
// required fixed32 to_set = 2;
- if (_has_bit(1)) {
+ if (has_to_set()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->to_set(), output);
}
-
+
// required .xtreemfs.pbrpc.XCap cap = 3;
- if (_has_bit(2)) {
+ if (has_cap()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3, this->cap(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -4940,24 +4977,24 @@ void fsetattrRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* fsetattrRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.Stat stbuf = 1;
- if (_has_bit(0)) {
+ if (has_stbuf()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->stbuf(), target);
}
-
+
// required fixed32 to_set = 2;
- if (_has_bit(1)) {
+ if (has_to_set()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->to_set(), target);
}
-
+
// required .xtreemfs.pbrpc.XCap cap = 3;
- if (_has_bit(2)) {
+ 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);
@@ -4967,7 +5004,7 @@ void fsetattrRequest::SerializeWithCachedSizes(
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()) {
@@ -4975,19 +5012,19 @@ int fsetattrRequest::ByteSize() const {
::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 +=
@@ -5015,13 +5052,13 @@ void fsetattrRequest::MergeFrom(const ::google::protobuf::Message& from) {
void fsetattrRequest::MergeFrom(const fsetattrRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_stbuf()) {
mutable_stbuf()->::xtreemfs::pbrpc::Stat::MergeFrom(from.stbuf());
}
- if (from._has_bit(1)) {
+ if (from.has_to_set()) {
set_to_set(from.to_set());
}
- if (from._has_bit(2)) {
+ if (from.has_cap()) {
mutable_cap()->::xtreemfs::pbrpc::XCap::MergeFrom(from.cap());
}
}
@@ -5042,7 +5079,7 @@ void fsetattrRequest::CopyFrom(const fsetattrRequest& from) {
bool fsetattrRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
if (has_stbuf()) {
if (!this->stbuf().IsInitialized()) return false;
}
@@ -5074,8 +5111,6 @@ void fsetattrRequest::Swap(fsetattrRequest* other) {
// ===================================================================
-const ::std::string getattrRequest::_default_volume_name_;
-const ::std::string getattrRequest::_default_path_;
#ifndef _MSC_VER
const int getattrRequest::kVolumeNameFieldNumber;
const int getattrRequest::kPathFieldNumber;
@@ -5098,8 +5133,8 @@ getattrRequest::getattrRequest(const getattrRequest& from)
void getattrRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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_));
}
@@ -5109,10 +5144,10 @@ getattrRequest::~getattrRequest() {
}
void getattrRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -5130,7 +5165,8 @@ const ::google::protobuf::Descriptor* getattrRequest::descriptor() {
}
const getattrRequest& getattrRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
getattrRequest* getattrRequest::default_instance_ = NULL;
@@ -5141,13 +5177,13 @@ getattrRequest* getattrRequest::New() const {
void getattrRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -5178,7 +5214,7 @@ bool getattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5195,7 +5231,7 @@ bool getattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(25)) goto parse_known_etag;
break;
}
-
+
// required fixed64 known_etag = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5204,14 +5240,14 @@ bool getattrRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &known_etag_)));
- _set_bit(2);
+ set_has_known_etag();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5231,28 +5267,28 @@ bool getattrRequest::MergePartialFromCodedStream(
void getattrRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required fixed64 known_etag = 3;
- if (_has_bit(2)) {
+ 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);
@@ -5262,7 +5298,7 @@ void getattrRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* getattrRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -5270,9 +5306,9 @@ void getattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -5280,12 +5316,12 @@ void getattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required fixed64 known_etag = 3;
- if (_has_bit(2)) {
+ 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);
@@ -5295,7 +5331,7 @@ void getattrRequest::SerializeWithCachedSizes(
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()) {
@@ -5303,19 +5339,19 @@ int getattrRequest::ByteSize() const {
::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 +=
@@ -5343,13 +5379,13 @@ void getattrRequest::MergeFrom(const ::google::protobuf::Message& from) {
void getattrRequest::MergeFrom(const getattrRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_known_etag()) {
set_known_etag(from.known_etag());
}
}
@@ -5370,7 +5406,7 @@ void getattrRequest::CopyFrom(const getattrRequest& from) {
bool getattrRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -5442,7 +5478,8 @@ const ::google::protobuf::Descriptor* getattrResponse::descriptor() {
}
const getattrResponse& getattrResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
getattrResponse* getattrResponse::default_instance_ = NULL;
@@ -5453,7 +5490,7 @@ getattrResponse* getattrResponse::New() const {
void getattrResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_stbuf()) {
if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear();
}
}
@@ -5479,7 +5516,7 @@ bool getattrResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5499,11 +5536,11 @@ bool getattrResponse::MergePartialFromCodedStream(
void getattrResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional .xtreemfs.pbrpc.Stat stbuf = 1;
- if (_has_bit(0)) {
+ if (has_stbuf()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->stbuf(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -5513,12 +5550,12 @@ void getattrResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* getattrResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional .xtreemfs.pbrpc.Stat stbuf = 1;
- if (_has_bit(0)) {
+ 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);
@@ -5528,7 +5565,7 @@ void getattrResponse::SerializeWithCachedSizes(
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()) {
@@ -5536,7 +5573,7 @@ int getattrResponse::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->stbuf());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -5564,7 +5601,7 @@ void getattrResponse::MergeFrom(const ::google::protobuf::Message& from) {
void getattrResponse::MergeFrom(const getattrResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_stbuf()) {
mutable_stbuf()->::xtreemfs::pbrpc::Stat::MergeFrom(from.stbuf());
}
}
@@ -5584,7 +5621,7 @@ void getattrResponse::CopyFrom(const getattrResponse& from) {
}
bool getattrResponse::IsInitialized() const {
-
+
if (has_stbuf()) {
if (!this->stbuf().IsInitialized()) return false;
}
@@ -5611,9 +5648,6 @@ void getattrResponse::Swap(getattrResponse* other) {
// ===================================================================
-const ::std::string getxattrRequest::_default_volume_name_;
-const ::std::string getxattrRequest::_default_path_;
-const ::std::string getxattrRequest::_default_name_;
#ifndef _MSC_VER
const int getxattrRequest::kVolumeNameFieldNumber;
const int getxattrRequest::kPathFieldNumber;
@@ -5636,9 +5670,9 @@ getxattrRequest::getxattrRequest(const getxattrRequest& from)
void getxattrRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
- name_ = const_cast< ::std::string*>(&_default_name_);
+ 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_));
}
@@ -5647,13 +5681,13 @@ getxattrRequest::~getxattrRequest() {
}
void getxattrRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
if (this != default_instance_) {
@@ -5671,7 +5705,8 @@ const ::google::protobuf::Descriptor* getxattrRequest::descriptor() {
}
const getxattrRequest& getxattrRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
getxattrRequest* getxattrRequest::default_instance_ = NULL;
@@ -5682,18 +5717,18 @@ getxattrRequest* getxattrRequest::New() const {
void getxattrRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
- if (_has_bit(2)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
@@ -5723,7 +5758,7 @@ bool getxattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5740,7 +5775,7 @@ bool getxattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_name;
break;
}
-
+
// required string name = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5757,7 +5792,7 @@ bool getxattrRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -5777,32 +5812,32 @@ bool getxattrRequest::MergePartialFromCodedStream(
void getxattrRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required string name = 3;
- if (_has_bit(2)) {
+ 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);
@@ -5812,7 +5847,7 @@ void getxattrRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* getxattrRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -5820,9 +5855,9 @@ void getxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -5830,9 +5865,9 @@ void getxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required string name = 3;
- if (_has_bit(2)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -5840,7 +5875,7 @@ void getxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -5850,7 +5885,7 @@ void getxattrRequest::SerializeWithCachedSizes(
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()) {
@@ -5858,21 +5893,21 @@ int getxattrRequest::ByteSize() const {
::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 +=
@@ -5900,13 +5935,13 @@ void getxattrRequest::MergeFrom(const ::google::protobuf::Message& from) {
void getxattrRequest::MergeFrom(const getxattrRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_name()) {
set_name(from.name());
}
}
@@ -5927,7 +5962,7 @@ void getxattrRequest::CopyFrom(const getxattrRequest& from) {
bool getxattrRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -5953,11 +5988,9 @@ void getxattrRequest::Swap(getxattrRequest* other) {
// ===================================================================
-const ::std::string getxattrResponse::_default_value_;
-const ::std::string getxattrResponse::_default_value_bytes_;
#ifndef _MSC_VER
const int getxattrResponse::kValueFieldNumber;
-const int getxattrResponse::kValueBytesFieldNumber;
+const int getxattrResponse::kValueBytesStringFieldNumber;
#endif // !_MSC_VER
getxattrResponse::getxattrResponse()
@@ -5976,8 +6009,8 @@ getxattrResponse::getxattrResponse(const getxattrResponse& from)
void getxattrResponse::SharedCtor() {
_cached_size_ = 0;
- value_ = const_cast< ::std::string*>(&_default_value_);
- value_bytes_ = const_cast< ::std::string*>(&_default_value_bytes_);
+ 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_));
}
@@ -5986,11 +6019,11 @@ getxattrResponse::~getxattrResponse() {
}
void getxattrResponse::SharedDtor() {
- if (value_ != &_default_value_) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
delete value_;
}
- if (value_bytes_ != &_default_value_bytes_) {
- delete value_bytes_;
+ if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) {
+ delete value_bytes_string_;
}
if (this != default_instance_) {
}
@@ -6007,7 +6040,8 @@ const ::google::protobuf::Descriptor* getxattrResponse::descriptor() {
}
const getxattrResponse& getxattrResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
getxattrResponse* getxattrResponse::default_instance_ = NULL;
@@ -6018,14 +6052,14 @@ getxattrResponse* getxattrResponse::New() const {
void getxattrResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (value_ != &_default_value_) {
+ if (has_value()) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
value_->clear();
}
}
- if (_has_bit(1)) {
- if (value_bytes_ != &_default_value_bytes_) {
- value_bytes_->clear();
+ if (has_value_bytes_string()) {
+ if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) {
+ value_bytes_string_->clear();
}
}
}
@@ -6051,24 +6085,24 @@ bool getxattrResponse::MergePartialFromCodedStream(
} else {
goto handle_uninterpreted;
}
- if (input->ExpectTag(18)) goto parse_value_bytes;
+ if (input->ExpectTag(18)) goto parse_value_bytes_string;
break;
}
-
- // optional bytes value_bytes = 2;
+
+ // 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:
+ parse_value_bytes_string:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
- input, this->mutable_value_bytes()));
+ 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) ==
@@ -6088,20 +6122,20 @@ bool getxattrResponse::MergePartialFromCodedStream(
void getxattrResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string value = 1;
- if (_has_bit(0)) {
+ 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 = 2;
- if (_has_bit(1)) {
+
+ // optional bytes value_bytes_string = 2;
+ if (has_value_bytes_string()) {
::google::protobuf::internal::WireFormatLite::WriteBytes(
- 2, this->value_bytes(), output);
+ 2, this->value_bytes_string(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -6111,7 +6145,7 @@ void getxattrResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* getxattrResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string value = 1;
- if (_has_bit(0)) {
+ if (has_value()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->value().data(), this->value().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -6119,14 +6153,14 @@ void getxattrResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->value(), target);
}
-
- // optional bytes value_bytes = 2;
- if (_has_bit(1)) {
+
+ // optional bytes value_bytes_string = 2;
+ if (has_value_bytes_string()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
- 2, this->value_bytes(), target);
+ 2, this->value_bytes_string(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -6136,7 +6170,7 @@ void getxattrResponse::SerializeWithCachedSizes(
int getxattrResponse::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string value = 1;
if (has_value()) {
@@ -6144,14 +6178,14 @@ int getxattrResponse::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->value());
}
-
- // optional bytes value_bytes = 2;
- if (has_value_bytes()) {
+
+ // optional bytes value_bytes_string = 2;
+ if (has_value_bytes_string()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
- this->value_bytes());
+ this->value_bytes_string());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -6179,11 +6213,11 @@ void getxattrResponse::MergeFrom(const ::google::protobuf::Message& from) {
void getxattrResponse::MergeFrom(const getxattrResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_value()) {
set_value(from.value());
}
- if (from._has_bit(1)) {
- set_value_bytes(from.value_bytes());
+ if (from.has_value_bytes_string()) {
+ set_value_bytes_string(from.value_bytes_string());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
@@ -6203,14 +6237,14 @@ void getxattrResponse::CopyFrom(const getxattrResponse& 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_, other->value_bytes_);
+ 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_);
@@ -6228,9 +6262,6 @@ void getxattrResponse::Swap(getxattrResponse* other) {
// ===================================================================
-const ::std::string linkRequest::_default_volume_name_;
-const ::std::string linkRequest::_default_target_path_;
-const ::std::string linkRequest::_default_link_path_;
#ifndef _MSC_VER
const int linkRequest::kVolumeNameFieldNumber;
const int linkRequest::kTargetPathFieldNumber;
@@ -6253,9 +6284,9 @@ linkRequest::linkRequest(const linkRequest& from)
void linkRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- target_path_ = const_cast< ::std::string*>(&_default_target_path_);
- link_path_ = const_cast< ::std::string*>(&_default_link_path_);
+ 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_));
}
@@ -6264,13 +6295,13 @@ linkRequest::~linkRequest() {
}
void linkRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (target_path_ != &_default_target_path_) {
+ if (target_path_ != &::google::protobuf::internal::kEmptyString) {
delete target_path_;
}
- if (link_path_ != &_default_link_path_) {
+ if (link_path_ != &::google::protobuf::internal::kEmptyString) {
delete link_path_;
}
if (this != default_instance_) {
@@ -6288,7 +6319,8 @@ const ::google::protobuf::Descriptor* linkRequest::descriptor() {
}
const linkRequest& linkRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
linkRequest* linkRequest::default_instance_ = NULL;
@@ -6299,18 +6331,18 @@ linkRequest* linkRequest::New() const {
void linkRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (target_path_ != &_default_target_path_) {
+ if (has_target_path()) {
+ if (target_path_ != &::google::protobuf::internal::kEmptyString) {
target_path_->clear();
}
}
- if (_has_bit(2)) {
- if (link_path_ != &_default_link_path_) {
+ if (has_link_path()) {
+ if (link_path_ != &::google::protobuf::internal::kEmptyString) {
link_path_->clear();
}
}
@@ -6340,7 +6372,7 @@ bool linkRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_target_path;
break;
}
-
+
// required string target_path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -6357,7 +6389,7 @@ bool linkRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_link_path;
break;
}
-
+
// required string link_path = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -6374,7 +6406,7 @@ bool linkRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -6394,32 +6426,32 @@ bool linkRequest::MergePartialFromCodedStream(
void linkRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ 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_bit(2)) {
+ 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);
@@ -6429,7 +6461,7 @@ void linkRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* linkRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -6437,9 +6469,9 @@ void linkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string target_path = 2;
- if (_has_bit(1)) {
+ if (has_target_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->target_path().data(), this->target_path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -6447,9 +6479,9 @@ void linkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->target_path(), target);
}
-
+
// required string link_path = 3;
- if (_has_bit(2)) {
+ if (has_link_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->link_path().data(), this->link_path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -6457,7 +6489,7 @@ void linkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->link_path(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -6467,7 +6499,7 @@ void linkRequest::SerializeWithCachedSizes(
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()) {
@@ -6475,21 +6507,21 @@ int linkRequest::ByteSize() const {
::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 +=
@@ -6517,13 +6549,13 @@ void linkRequest::MergeFrom(const ::google::protobuf::Message& from) {
void linkRequest::MergeFrom(const linkRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_target_path()) {
set_target_path(from.target_path());
}
- if (from._has_bit(2)) {
+ if (from.has_link_path()) {
set_link_path(from.link_path());
}
}
@@ -6544,7 +6576,7 @@ void linkRequest::CopyFrom(const linkRequest& from) {
bool linkRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -6570,8 +6602,6 @@ void linkRequest::Swap(linkRequest* other) {
// ===================================================================
-const ::std::string listxattrRequest::_default_volume_name_;
-const ::std::string listxattrRequest::_default_path_;
#ifndef _MSC_VER
const int listxattrRequest::kVolumeNameFieldNumber;
const int listxattrRequest::kPathFieldNumber;
@@ -6594,8 +6624,8 @@ listxattrRequest::listxattrRequest(const listxattrRequest& from)
void listxattrRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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_));
}
@@ -6605,10 +6635,10 @@ listxattrRequest::~listxattrRequest() {
}
void listxattrRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -6626,7 +6656,8 @@ const ::google::protobuf::Descriptor* listxattrRequest::descriptor() {
}
const listxattrRequest& listxattrRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
listxattrRequest* listxattrRequest::default_instance_ = NULL;
@@ -6637,13 +6668,13 @@ listxattrRequest* listxattrRequest::New() const {
void listxattrRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -6674,7 +6705,7 @@ bool listxattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -6691,7 +6722,7 @@ bool listxattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(24)) goto parse_names_only;
break;
}
-
+
// required bool names_only = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -6700,14 +6731,14 @@ bool listxattrRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &names_only_)));
- _set_bit(2);
+ set_has_names_only();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -6727,28 +6758,28 @@ bool listxattrRequest::MergePartialFromCodedStream(
void listxattrRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required bool names_only = 3;
- if (_has_bit(2)) {
+ 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);
@@ -6758,7 +6789,7 @@ void listxattrRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* listxattrRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -6766,9 +6797,9 @@ void listxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -6776,12 +6807,12 @@ void listxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required bool names_only = 3;
- if (_has_bit(2)) {
+ 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);
@@ -6791,7 +6822,7 @@ void listxattrRequest::SerializeWithCachedSizes(
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()) {
@@ -6799,19 +6830,19 @@ int listxattrRequest::ByteSize() const {
::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 +=
@@ -6839,13 +6870,13 @@ void listxattrRequest::MergeFrom(const ::google::protobuf::Message& from) {
void listxattrRequest::MergeFrom(const listxattrRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_names_only()) {
set_names_only(from.names_only());
}
}
@@ -6866,7 +6897,7 @@ void listxattrRequest::CopyFrom(const listxattrRequest& from) {
bool listxattrRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -6935,7 +6966,8 @@ const ::google::protobuf::Descriptor* listxattrResponse::descriptor() {
}
const listxattrResponse& listxattrResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
listxattrResponse* listxattrResponse::default_instance_ = NULL;
@@ -6970,7 +7002,7 @@ bool listxattrResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -6994,7 +7026,7 @@ void listxattrResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->xattrs(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -7009,7 +7041,7 @@ void listxattrResponse::SerializeWithCachedSizes(
WriteMessageNoVirtualToArray(
1, this->xattrs(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -7019,7 +7051,7 @@ void listxattrResponse::SerializeWithCachedSizes(
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++) {
@@ -7027,7 +7059,7 @@ int listxattrResponse::ByteSize() const {
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->xattrs(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -7070,7 +7102,7 @@ void listxattrResponse::CopyFrom(const listxattrResponse& from) {
}
bool listxattrResponse::IsInitialized() const {
-
+
for (int i = 0; i < xattrs_size(); i++) {
if (!this->xattrs(i).IsInitialized()) return false;
}
@@ -7097,8 +7129,6 @@ void listxattrResponse::Swap(listxattrResponse* other) {
// ===================================================================
-const ::std::string mkdirRequest::_default_volume_name_;
-const ::std::string mkdirRequest::_default_path_;
#ifndef _MSC_VER
const int mkdirRequest::kVolumeNameFieldNumber;
const int mkdirRequest::kPathFieldNumber;
@@ -7121,8 +7151,8 @@ mkdirRequest::mkdirRequest(const mkdirRequest& from)
void mkdirRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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_));
}
@@ -7132,10 +7162,10 @@ mkdirRequest::~mkdirRequest() {
}
void mkdirRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -7153,7 +7183,8 @@ const ::google::protobuf::Descriptor* mkdirRequest::descriptor() {
}
const mkdirRequest& mkdirRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
mkdirRequest* mkdirRequest::default_instance_ = NULL;
@@ -7164,13 +7195,13 @@ mkdirRequest* mkdirRequest::New() const {
void mkdirRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -7201,7 +7232,7 @@ bool mkdirRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -7218,7 +7249,7 @@ bool mkdirRequest::MergePartialFromCodedStream(
if (input->ExpectTag(29)) goto parse_mode;
break;
}
-
+
// required fixed32 mode = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -7227,14 +7258,14 @@ bool mkdirRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &mode_)));
- _set_bit(2);
+ set_has_mode();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -7254,28 +7285,28 @@ bool mkdirRequest::MergePartialFromCodedStream(
void mkdirRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required fixed32 mode = 3;
- if (_has_bit(2)) {
+ if (has_mode()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->mode(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -7285,7 +7316,7 @@ void mkdirRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* mkdirRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -7293,9 +7324,9 @@ void mkdirRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -7303,12 +7334,12 @@ void mkdirRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required fixed32 mode = 3;
- if (_has_bit(2)) {
+ 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);
@@ -7318,7 +7349,7 @@ void mkdirRequest::SerializeWithCachedSizes(
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()) {
@@ -7326,19 +7357,19 @@ int mkdirRequest::ByteSize() const {
::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 +=
@@ -7366,13 +7397,13 @@ void mkdirRequest::MergeFrom(const ::google::protobuf::Message& from) {
void mkdirRequest::MergeFrom(const mkdirRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_mode()) {
set_mode(from.mode());
}
}
@@ -7393,7 +7424,7 @@ void mkdirRequest::CopyFrom(const mkdirRequest& from) {
bool mkdirRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -7419,8 +7450,6 @@ void mkdirRequest::Swap(mkdirRequest* other) {
// ===================================================================
-const ::std::string openRequest::_default_volume_name_;
-const ::std::string openRequest::_default_path_;
#ifndef _MSC_VER
const int openRequest::kVolumeNameFieldNumber;
const int openRequest::kPathFieldNumber;
@@ -7447,8 +7476,8 @@ openRequest::openRequest(const openRequest& from)
void openRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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;
@@ -7461,10 +7490,10 @@ openRequest::~openRequest() {
}
void openRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -7483,7 +7512,8 @@ const ::google::protobuf::Descriptor* openRequest::descriptor() {
}
const openRequest& openRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
openRequest* openRequest::default_instance_ = NULL;
@@ -7494,20 +7524,20 @@ openRequest* openRequest::New() const {
void openRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
flags_ = 0u;
mode_ = 0u;
attributes_ = 0u;
- if (_has_bit(5)) {
+ if (has_coordinates()) {
if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear();
}
}
@@ -7536,7 +7566,7 @@ bool openRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -7553,7 +7583,7 @@ bool openRequest::MergePartialFromCodedStream(
if (input->ExpectTag(29)) goto parse_flags;
break;
}
-
+
// required fixed32 flags = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -7562,14 +7592,14 @@ bool openRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &flags_)));
- _set_bit(2);
+ 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) ==
@@ -7578,14 +7608,14 @@ bool openRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &mode_)));
- _set_bit(3);
+ 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) ==
@@ -7594,14 +7624,14 @@ bool openRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &attributes_)));
- _set_bit(4);
+ 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) ==
@@ -7615,7 +7645,7 @@ bool openRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -7635,44 +7665,44 @@ bool openRequest::MergePartialFromCodedStream(
void openRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required fixed32 flags = 3;
- if (_has_bit(2)) {
+ if (has_flags()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->flags(), output);
}
-
+
// required fixed32 mode = 4;
- if (_has_bit(3)) {
+ if (has_mode()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->mode(), output);
}
-
+
// required fixed32 attributes = 5;
- if (_has_bit(4)) {
+ if (has_attributes()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->attributes(), output);
}
-
+
// optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6;
- if (_has_bit(5)) {
+ if (has_coordinates()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
6, this->coordinates(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -7682,7 +7712,7 @@ void openRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* openRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -7690,9 +7720,9 @@ void openRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -7700,29 +7730,29 @@ void openRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required fixed32 flags = 3;
- if (_has_bit(2)) {
+ if (has_flags()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->flags(), target);
}
-
+
// required fixed32 mode = 4;
- if (_has_bit(3)) {
+ if (has_mode()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->mode(), target);
}
-
+
// required fixed32 attributes = 5;
- if (_has_bit(4)) {
+ if (has_attributes()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->attributes(), target);
}
-
+
// optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6;
- if (_has_bit(5)) {
+ 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);
@@ -7732,7 +7762,7 @@ void openRequest::SerializeWithCachedSizes(
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()) {
@@ -7740,36 +7770,36 @@ int openRequest::ByteSize() const {
::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 +=
@@ -7797,22 +7827,22 @@ void openRequest::MergeFrom(const ::google::protobuf::Message& from) {
void openRequest::MergeFrom(const openRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_flags()) {
set_flags(from.flags());
}
- if (from._has_bit(3)) {
+ if (from.has_mode()) {
set_mode(from.mode());
}
- if (from._has_bit(4)) {
+ if (from.has_attributes()) {
set_attributes(from.attributes());
}
- if (from._has_bit(5)) {
+ if (from.has_coordinates()) {
mutable_coordinates()->::xtreemfs::pbrpc::VivaldiCoordinates::MergeFrom(from.coordinates());
}
}
@@ -7833,7 +7863,7 @@ void openRequest::CopyFrom(const openRequest& from) {
bool openRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;
-
+
if (has_coordinates()) {
if (!this->coordinates().IsInitialized()) return false;
}
@@ -7913,7 +7943,8 @@ const ::google::protobuf::Descriptor* openResponse::descriptor() {
}
const openResponse& openResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
openResponse* openResponse::default_instance_ = NULL;
@@ -7924,7 +7955,7 @@ openResponse* openResponse::New() const {
void openResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_creds()) {
if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear();
}
timestamp_s_ = 0u;
@@ -7951,7 +7982,7 @@ bool openResponse::MergePartialFromCodedStream(
if (input->ExpectTag(21)) goto parse_timestamp_s;
break;
}
-
+
// required fixed32 timestamp_s = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -7960,14 +7991,14 @@ bool openResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, ×tamp_s_)));
- _set_bit(1);
+ set_has_timestamp_s();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -7987,16 +8018,16 @@ bool openResponse::MergePartialFromCodedStream(
void openResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.FileCredentials creds = 1;
- if (_has_bit(0)) {
+ if (has_creds()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->creds(), output);
}
-
+
// required fixed32 timestamp_s = 2;
- if (_has_bit(1)) {
+ 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);
@@ -8006,17 +8037,17 @@ void openResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* openResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.FileCredentials creds = 1;
- if (_has_bit(0)) {
+ if (has_creds()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->creds(), target);
}
-
+
// required fixed32 timestamp_s = 2;
- if (_has_bit(1)) {
+ 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);
@@ -8026,7 +8057,7 @@ void openResponse::SerializeWithCachedSizes(
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()) {
@@ -8034,12 +8065,12 @@ int openResponse::ByteSize() const {
::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 +=
@@ -8067,10 +8098,10 @@ void openResponse::MergeFrom(const ::google::protobuf::Message& from) {
void openResponse::MergeFrom(const openResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_creds()) {
mutable_creds()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.creds());
}
- if (from._has_bit(1)) {
+ if (from.has_timestamp_s()) {
set_timestamp_s(from.timestamp_s());
}
}
@@ -8091,7 +8122,7 @@ void openResponse::CopyFrom(const openResponse& from) {
bool openResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
if (has_creds()) {
if (!this->creds().IsInitialized()) return false;
}
@@ -8119,8 +8150,6 @@ void openResponse::Swap(openResponse* other) {
// ===================================================================
-const ::std::string readdirRequest::_default_volume_name_;
-const ::std::string readdirRequest::_default_path_;
#ifndef _MSC_VER
const int readdirRequest::kVolumeNameFieldNumber;
const int readdirRequest::kPathFieldNumber;
@@ -8146,8 +8175,8 @@ readdirRequest::readdirRequest(const readdirRequest& from)
void readdirRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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;
@@ -8160,10 +8189,10 @@ readdirRequest::~readdirRequest() {
}
void readdirRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -8181,7 +8210,8 @@ const ::google::protobuf::Descriptor* readdirRequest::descriptor() {
}
const readdirRequest& readdirRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
readdirRequest* readdirRequest::default_instance_ = NULL;
@@ -8192,13 +8222,13 @@ readdirRequest* readdirRequest::New() const {
void readdirRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -8232,7 +8262,7 @@ bool readdirRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -8249,7 +8279,7 @@ bool readdirRequest::MergePartialFromCodedStream(
if (input->ExpectTag(25)) goto parse_known_etag;
break;
}
-
+
// required fixed64 known_etag = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -8258,14 +8288,14 @@ bool readdirRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &known_etag_)));
- _set_bit(2);
+ 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) ==
@@ -8274,14 +8304,14 @@ bool readdirRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &limit_directory_entries_count_)));
- _set_bit(3);
+ 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) ==
@@ -8290,14 +8320,14 @@ bool readdirRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &names_only_)));
- _set_bit(4);
+ 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) ==
@@ -8306,14 +8336,14 @@ bool readdirRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &seen_directory_entries_count_)));
- _set_bit(5);
+ 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) ==
@@ -8333,43 +8363,43 @@ bool readdirRequest::MergePartialFromCodedStream(
void readdirRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required fixed64 known_etag = 3;
- if (_has_bit(2)) {
+ if (has_known_etag()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->known_etag(), output);
}
-
+
// required fixed32 limit_directory_entries_count = 4;
- if (_has_bit(3)) {
+ 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_bit(4)) {
+ if (has_names_only()) {
::google::protobuf::internal::WireFormatLite::WriteBool(5, this->names_only(), output);
}
-
+
// required fixed64 seen_directory_entries_count = 6;
- if (_has_bit(5)) {
+ 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);
@@ -8379,7 +8409,7 @@ void readdirRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* readdirRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -8387,9 +8417,9 @@ void readdirRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -8397,27 +8427,27 @@ void readdirRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required fixed64 known_etag = 3;
- if (_has_bit(2)) {
+ if (has_known_etag()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->known_etag(), target);
}
-
+
// required fixed32 limit_directory_entries_count = 4;
- if (_has_bit(3)) {
+ 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_bit(4)) {
+ if (has_names_only()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->names_only(), target);
}
-
+
// required fixed64 seen_directory_entries_count = 6;
- if (_has_bit(5)) {
+ 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);
@@ -8427,7 +8457,7 @@ void readdirRequest::SerializeWithCachedSizes(
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()) {
@@ -8435,34 +8465,34 @@ int readdirRequest::ByteSize() const {
::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 +=
@@ -8490,22 +8520,22 @@ void readdirRequest::MergeFrom(const ::google::protobuf::Message& from) {
void readdirRequest::MergeFrom(const readdirRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_known_etag()) {
set_known_etag(from.known_etag());
}
- if (from._has_bit(3)) {
+ if (from.has_limit_directory_entries_count()) {
set_limit_directory_entries_count(from.limit_directory_entries_count());
}
- if (from._has_bit(4)) {
+ if (from.has_names_only()) {
set_names_only(from.names_only());
}
- if (from._has_bit(5)) {
+ if (from.has_seen_directory_entries_count()) {
set_seen_directory_entries_count(from.seen_directory_entries_count());
}
}
@@ -8526,7 +8556,7 @@ void readdirRequest::CopyFrom(const readdirRequest& from) {
bool readdirRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;
-
+
return true;
}
@@ -8555,8 +8585,6 @@ void readdirRequest::Swap(readdirRequest* other) {
// ===================================================================
-const ::std::string readlinkRequest::_default_volume_name_;
-const ::std::string readlinkRequest::_default_path_;
#ifndef _MSC_VER
const int readlinkRequest::kVolumeNameFieldNumber;
const int readlinkRequest::kPathFieldNumber;
@@ -8578,8 +8606,8 @@ readlinkRequest::readlinkRequest(const readlinkRequest& from)
void readlinkRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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_));
}
@@ -8588,10 +8616,10 @@ readlinkRequest::~readlinkRequest() {
}
void readlinkRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -8609,7 +8637,8 @@ const ::google::protobuf::Descriptor* readlinkRequest::descriptor() {
}
const readlinkRequest& readlinkRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
readlinkRequest* readlinkRequest::default_instance_ = NULL;
@@ -8620,13 +8649,13 @@ readlinkRequest* readlinkRequest::New() const {
void readlinkRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -8656,7 +8685,7 @@ bool readlinkRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -8673,7 +8702,7 @@ bool readlinkRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -8693,23 +8722,23 @@ bool readlinkRequest::MergePartialFromCodedStream(
void readlinkRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -8719,7 +8748,7 @@ void readlinkRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* readlinkRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -8727,9 +8756,9 @@ void readlinkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -8737,7 +8766,7 @@ void readlinkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -8747,7 +8776,7 @@ void readlinkRequest::SerializeWithCachedSizes(
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()) {
@@ -8755,14 +8784,14 @@ int readlinkRequest::ByteSize() const {
::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 +=
@@ -8790,10 +8819,10 @@ void readlinkRequest::MergeFrom(const ::google::protobuf::Message& from) {
void readlinkRequest::MergeFrom(const readlinkRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
}
@@ -8814,7 +8843,7 @@ void readlinkRequest::CopyFrom(const readlinkRequest& from) {
bool readlinkRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
@@ -8882,7 +8911,8 @@ const ::google::protobuf::Descriptor* readlinkResponse::descriptor() {
}
const readlinkResponse& readlinkResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
readlinkResponse* readlinkResponse::default_instance_ = NULL;
@@ -8911,7 +8941,8 @@ bool readlinkResponse::MergePartialFromCodedStream(
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->add_link_target_path()));
::google::protobuf::internal::WireFormat::VerifyUTF8String(
- this->link_target_path(0).data(), this->link_target_path(0).length(),
+ 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;
@@ -8920,7 +8951,7 @@ bool readlinkResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -8947,7 +8978,7 @@ void readlinkResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteString(
1, this->link_target_path(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -8964,7 +8995,7 @@ void readlinkResponse::SerializeWithCachedSizes(
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);
@@ -8974,14 +9005,14 @@ void readlinkResponse::SerializeWithCachedSizes(
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(
@@ -9024,7 +9055,7 @@ void readlinkResponse::CopyFrom(const readlinkResponse& from) {
}
bool readlinkResponse::IsInitialized() const {
-
+
return true;
}
@@ -9048,9 +9079,6 @@ void readlinkResponse::Swap(readlinkResponse* other) {
// ===================================================================
-const ::std::string removexattrRequest::_default_volume_name_;
-const ::std::string removexattrRequest::_default_path_;
-const ::std::string removexattrRequest::_default_name_;
#ifndef _MSC_VER
const int removexattrRequest::kVolumeNameFieldNumber;
const int removexattrRequest::kPathFieldNumber;
@@ -9073,9 +9101,9 @@ removexattrRequest::removexattrRequest(const removexattrRequest& from)
void removexattrRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
- name_ = const_cast< ::std::string*>(&_default_name_);
+ 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_));
}
@@ -9084,13 +9112,13 @@ removexattrRequest::~removexattrRequest() {
}
void removexattrRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
if (this != default_instance_) {
@@ -9108,7 +9136,8 @@ const ::google::protobuf::Descriptor* removexattrRequest::descriptor() {
}
const removexattrRequest& removexattrRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
removexattrRequest* removexattrRequest::default_instance_ = NULL;
@@ -9119,18 +9148,18 @@ removexattrRequest* removexattrRequest::New() const {
void removexattrRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
- if (_has_bit(2)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
@@ -9160,7 +9189,7 @@ bool removexattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -9177,7 +9206,7 @@ bool removexattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_name;
break;
}
-
+
// required string name = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -9194,7 +9223,7 @@ bool removexattrRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -9214,32 +9243,32 @@ bool removexattrRequest::MergePartialFromCodedStream(
void removexattrRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required string name = 3;
- if (_has_bit(2)) {
+ 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);
@@ -9249,7 +9278,7 @@ void removexattrRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* removexattrRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -9257,9 +9286,9 @@ void removexattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -9267,9 +9296,9 @@ void removexattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required string name = 3;
- if (_has_bit(2)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -9277,7 +9306,7 @@ void removexattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -9287,7 +9316,7 @@ void removexattrRequest::SerializeWithCachedSizes(
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()) {
@@ -9295,21 +9324,21 @@ int removexattrRequest::ByteSize() const {
::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 +=
@@ -9337,13 +9366,13 @@ void removexattrRequest::MergeFrom(const ::google::protobuf::Message& from) {
void removexattrRequest::MergeFrom(const removexattrRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_name()) {
set_name(from.name());
}
}
@@ -9364,7 +9393,7 @@ void removexattrRequest::CopyFrom(const removexattrRequest& from) {
bool removexattrRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -9390,9 +9419,6 @@ void removexattrRequest::Swap(removexattrRequest* other) {
// ===================================================================
-const ::std::string renameRequest::_default_volume_name_;
-const ::std::string renameRequest::_default_source_path_;
-const ::std::string renameRequest::_default_target_path_;
#ifndef _MSC_VER
const int renameRequest::kVolumeNameFieldNumber;
const int renameRequest::kSourcePathFieldNumber;
@@ -9415,9 +9441,9 @@ renameRequest::renameRequest(const renameRequest& from)
void renameRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- source_path_ = const_cast< ::std::string*>(&_default_source_path_);
- target_path_ = const_cast< ::std::string*>(&_default_target_path_);
+ 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_));
}
@@ -9426,13 +9452,13 @@ renameRequest::~renameRequest() {
}
void renameRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (source_path_ != &_default_source_path_) {
+ if (source_path_ != &::google::protobuf::internal::kEmptyString) {
delete source_path_;
}
- if (target_path_ != &_default_target_path_) {
+ if (target_path_ != &::google::protobuf::internal::kEmptyString) {
delete target_path_;
}
if (this != default_instance_) {
@@ -9450,7 +9476,8 @@ const ::google::protobuf::Descriptor* renameRequest::descriptor() {
}
const renameRequest& renameRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
renameRequest* renameRequest::default_instance_ = NULL;
@@ -9461,18 +9488,18 @@ renameRequest* renameRequest::New() const {
void renameRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (source_path_ != &_default_source_path_) {
+ if (has_source_path()) {
+ if (source_path_ != &::google::protobuf::internal::kEmptyString) {
source_path_->clear();
}
}
- if (_has_bit(2)) {
- if (target_path_ != &_default_target_path_) {
+ if (has_target_path()) {
+ if (target_path_ != &::google::protobuf::internal::kEmptyString) {
target_path_->clear();
}
}
@@ -9502,7 +9529,7 @@ bool renameRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_source_path;
break;
}
-
+
// required string source_path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -9519,7 +9546,7 @@ bool renameRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_target_path;
break;
}
-
+
// required string target_path = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -9536,7 +9563,7 @@ bool renameRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -9556,32 +9583,32 @@ bool renameRequest::MergePartialFromCodedStream(
void renameRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ 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_bit(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(
3, this->target_path(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -9591,7 +9618,7 @@ void renameRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* renameRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -9599,9 +9626,9 @@ void renameRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string source_path = 2;
- if (_has_bit(1)) {
+ if (has_source_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->source_path().data(), this->source_path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -9609,9 +9636,9 @@ void renameRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->source_path(), target);
}
-
+
// required string target_path = 3;
- if (_has_bit(2)) {
+ if (has_target_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->target_path().data(), this->target_path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -9619,7 +9646,7 @@ void renameRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->target_path(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -9629,7 +9656,7 @@ void renameRequest::SerializeWithCachedSizes(
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()) {
@@ -9637,21 +9664,21 @@ int renameRequest::ByteSize() const {
::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 +=
@@ -9679,13 +9706,13 @@ void renameRequest::MergeFrom(const ::google::protobuf::Message& from) {
void renameRequest::MergeFrom(const renameRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_source_path()) {
set_source_path(from.source_path());
}
- if (from._has_bit(2)) {
+ if (from.has_target_path()) {
set_target_path(from.target_path());
}
}
@@ -9706,7 +9733,7 @@ void renameRequest::CopyFrom(const renameRequest& from) {
bool renameRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -9780,7 +9807,8 @@ const ::google::protobuf::Descriptor* renameResponse::descriptor() {
}
const renameResponse& renameResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
renameResponse* renameResponse::default_instance_ = NULL;
@@ -9792,7 +9820,7 @@ renameResponse* renameResponse::New() const {
void renameResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
timestamp_s_ = 0u;
- if (_has_bit(1)) {
+ if (has_creds()) {
if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear();
}
}
@@ -9813,14 +9841,14 @@ bool renameResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, ×tamp_s_)));
- _set_bit(0);
+ 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) ==
@@ -9834,7 +9862,7 @@ bool renameResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -9854,16 +9882,16 @@ bool renameResponse::MergePartialFromCodedStream(
void renameResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed32 timestamp_s = 1;
- if (_has_bit(0)) {
+ if (has_timestamp_s()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->timestamp_s(), output);
}
-
+
// optional .xtreemfs.pbrpc.FileCredentials creds = 2;
- if (_has_bit(1)) {
+ if (has_creds()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->creds(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -9873,17 +9901,17 @@ void renameResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* renameResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed32 timestamp_s = 1;
- if (_has_bit(0)) {
+ if (has_timestamp_s()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->timestamp_s(), target);
}
-
+
// optional .xtreemfs.pbrpc.FileCredentials creds = 2;
- if (_has_bit(1)) {
+ 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);
@@ -9893,20 +9921,20 @@ void renameResponse::SerializeWithCachedSizes(
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 +=
@@ -9934,10 +9962,10 @@ void renameResponse::MergeFrom(const ::google::protobuf::Message& from) {
void renameResponse::MergeFrom(const renameResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_timestamp_s()) {
set_timestamp_s(from.timestamp_s());
}
- if (from._has_bit(1)) {
+ if (from.has_creds()) {
mutable_creds()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.creds());
}
}
@@ -9958,7 +9986,7 @@ void renameResponse::CopyFrom(const renameResponse& from) {
bool renameResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
if (has_creds()) {
if (!this->creds().IsInitialized()) return false;
}
@@ -9986,8 +10014,6 @@ void renameResponse::Swap(renameResponse* other) {
// ===================================================================
-const ::std::string rmdirRequest::_default_volume_name_;
-const ::std::string rmdirRequest::_default_path_;
#ifndef _MSC_VER
const int rmdirRequest::kVolumeNameFieldNumber;
const int rmdirRequest::kPathFieldNumber;
@@ -10009,8 +10035,8 @@ rmdirRequest::rmdirRequest(const rmdirRequest& from)
void rmdirRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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_));
}
@@ -10019,10 +10045,10 @@ rmdirRequest::~rmdirRequest() {
}
void rmdirRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -10040,7 +10066,8 @@ const ::google::protobuf::Descriptor* rmdirRequest::descriptor() {
}
const rmdirRequest& rmdirRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
rmdirRequest* rmdirRequest::default_instance_ = NULL;
@@ -10051,13 +10078,13 @@ rmdirRequest* rmdirRequest::New() const {
void rmdirRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -10087,7 +10114,7 @@ bool rmdirRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10104,7 +10131,7 @@ bool rmdirRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10124,23 +10151,23 @@ bool rmdirRequest::MergePartialFromCodedStream(
void rmdirRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -10150,7 +10177,7 @@ void rmdirRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* rmdirRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -10158,9 +10185,9 @@ void rmdirRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -10168,7 +10195,7 @@ void rmdirRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -10178,7 +10205,7 @@ void rmdirRequest::SerializeWithCachedSizes(
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()) {
@@ -10186,14 +10213,14 @@ int rmdirRequest::ByteSize() const {
::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 +=
@@ -10221,10 +10248,10 @@ void rmdirRequest::MergeFrom(const ::google::protobuf::Message& from) {
void rmdirRequest::MergeFrom(const rmdirRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
}
@@ -10245,7 +10272,7 @@ void rmdirRequest::CopyFrom(const rmdirRequest& from) {
bool rmdirRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
@@ -10270,8 +10297,6 @@ void rmdirRequest::Swap(rmdirRequest* other) {
// ===================================================================
-const ::std::string setattrRequest::_default_volume_name_;
-const ::std::string setattrRequest::_default_path_;
#ifndef _MSC_VER
const int setattrRequest::kVolumeNameFieldNumber;
const int setattrRequest::kPathFieldNumber;
@@ -10296,8 +10321,8 @@ setattrRequest::setattrRequest(const setattrRequest& from)
void setattrRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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_));
@@ -10308,10 +10333,10 @@ setattrRequest::~setattrRequest() {
}
void setattrRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -10330,7 +10355,8 @@ const ::google::protobuf::Descriptor* setattrRequest::descriptor() {
}
const setattrRequest& setattrRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
setattrRequest* setattrRequest::default_instance_ = NULL;
@@ -10341,17 +10367,17 @@ setattrRequest* setattrRequest::New() const {
void setattrRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
- if (_has_bit(2)) {
+ if (has_stbuf()) {
if (stbuf_ != NULL) stbuf_->::xtreemfs::pbrpc::Stat::Clear();
}
to_set_ = 0u;
@@ -10381,7 +10407,7 @@ bool setattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10398,7 +10424,7 @@ bool setattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_stbuf;
break;
}
-
+
// required .xtreemfs.pbrpc.Stat stbuf = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10412,7 +10438,7 @@ bool setattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(37)) goto parse_to_set;
break;
}
-
+
// required fixed32 to_set = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10421,14 +10447,14 @@ bool setattrRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &to_set_)));
- _set_bit(3);
+ set_has_to_set();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10448,34 +10474,34 @@ bool setattrRequest::MergePartialFromCodedStream(
void setattrRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required .xtreemfs.pbrpc.Stat stbuf = 3;
- if (_has_bit(2)) {
+ if (has_stbuf()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3, this->stbuf(), output);
}
-
+
// required fixed32 to_set = 4;
- if (_has_bit(3)) {
+ 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);
@@ -10485,7 +10511,7 @@ void setattrRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* setattrRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -10493,9 +10519,9 @@ void setattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -10503,19 +10529,19 @@ void setattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required .xtreemfs.pbrpc.Stat stbuf = 3;
- if (_has_bit(2)) {
+ if (has_stbuf()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
3, this->stbuf(), target);
}
-
+
// required fixed32 to_set = 4;
- if (_has_bit(3)) {
+ 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);
@@ -10525,7 +10551,7 @@ void setattrRequest::SerializeWithCachedSizes(
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()) {
@@ -10533,26 +10559,26 @@ int setattrRequest::ByteSize() const {
::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 +=
@@ -10580,16 +10606,16 @@ void setattrRequest::MergeFrom(const ::google::protobuf::Message& from) {
void setattrRequest::MergeFrom(const setattrRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_stbuf()) {
mutable_stbuf()->::xtreemfs::pbrpc::Stat::MergeFrom(from.stbuf());
}
- if (from._has_bit(3)) {
+ if (from.has_to_set()) {
set_to_set(from.to_set());
}
}
@@ -10610,7 +10636,7 @@ void setattrRequest::CopyFrom(const setattrRequest& from) {
bool setattrRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
-
+
if (has_stbuf()) {
if (!this->stbuf().IsInitialized()) return false;
}
@@ -10640,17 +10666,12 @@ void setattrRequest::Swap(setattrRequest* other) {
// ===================================================================
-const ::std::string setxattrRequest::_default_volume_name_;
-const ::std::string setxattrRequest::_default_path_;
-const ::std::string setxattrRequest::_default_name_;
-const ::std::string setxattrRequest::_default_value_;
-const ::std::string setxattrRequest::_default_value_bytes_;
#ifndef _MSC_VER
const int setxattrRequest::kVolumeNameFieldNumber;
const int setxattrRequest::kPathFieldNumber;
const int setxattrRequest::kNameFieldNumber;
const int setxattrRequest::kValueFieldNumber;
-const int setxattrRequest::kValueBytesFieldNumber;
+const int setxattrRequest::kValueBytesStringFieldNumber;
const int setxattrRequest::kFlagsFieldNumber;
#endif // !_MSC_VER
@@ -10670,11 +10691,11 @@ setxattrRequest::setxattrRequest(const setxattrRequest& from)
void setxattrRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
- name_ = const_cast< ::std::string*>(&_default_name_);
- value_ = const_cast< ::std::string*>(&_default_value_);
- value_bytes_ = const_cast< ::std::string*>(&_default_value_bytes_);
+ 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_));
}
@@ -10684,20 +10705,20 @@ setxattrRequest::~setxattrRequest() {
}
void setxattrRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
- if (name_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
delete name_;
}
- if (value_ != &_default_value_) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
delete value_;
}
- if (value_bytes_ != &_default_value_bytes_) {
- delete value_bytes_;
+ if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) {
+ delete value_bytes_string_;
}
if (this != default_instance_) {
}
@@ -10714,7 +10735,8 @@ const ::google::protobuf::Descriptor* setxattrRequest::descriptor() {
}
const setxattrRequest& setxattrRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
setxattrRequest* setxattrRequest::default_instance_ = NULL;
@@ -10725,29 +10747,29 @@ setxattrRequest* setxattrRequest::New() const {
void setxattrRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
- if (_has_bit(2)) {
- if (name_ != &_default_name_) {
+ if (has_name()) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
- if (_has_bit(3)) {
- if (value_ != &_default_value_) {
+ if (has_value()) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
value_->clear();
}
}
- if (_has_bit(4)) {
- if (value_bytes_ != &_default_value_bytes_) {
- value_bytes_->clear();
+ if (has_value_bytes_string()) {
+ if (value_bytes_string_ != &::google::protobuf::internal::kEmptyString) {
+ value_bytes_string_->clear();
}
}
flags_ = 0u;
@@ -10777,7 +10799,7 @@ bool setxattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10794,7 +10816,7 @@ bool setxattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_name;
break;
}
-
+
// required string name = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10811,7 +10833,7 @@ bool setxattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(34)) goto parse_value;
break;
}
-
+
// required string value = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10828,7 +10850,7 @@ bool setxattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(45)) goto parse_flags;
break;
}
-
+
// required fixed32 flags = 5;
case 5: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -10837,28 +10859,28 @@ bool setxattrRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &flags_)));
- _set_bit(5);
+ set_has_flags();
} else {
goto handle_uninterpreted;
}
- if (input->ExpectTag(50)) goto parse_value_bytes;
+ if (input->ExpectTag(50)) goto parse_value_bytes_string;
break;
}
-
- // optional bytes value_bytes = 6;
+
+ // 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:
+ parse_value_bytes_string:
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
- input, this->mutable_value_bytes()));
+ 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) ==
@@ -10878,52 +10900,52 @@ bool setxattrRequest::MergePartialFromCodedStream(
void setxattrRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required string name = 3;
- if (_has_bit(2)) {
+ 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_bit(3)) {
+ 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_bit(5)) {
+ if (has_flags()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->flags(), output);
}
-
- // optional bytes value_bytes = 6;
- if (_has_bit(4)) {
+
+ // optional bytes value_bytes_string = 6;
+ if (has_value_bytes_string()) {
::google::protobuf::internal::WireFormatLite::WriteBytes(
- 6, this->value_bytes(), output);
+ 6, this->value_bytes_string(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -10933,7 +10955,7 @@ void setxattrRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* setxattrRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -10941,9 +10963,9 @@ void setxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -10951,9 +10973,9 @@ void setxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required string name = 3;
- if (_has_bit(2)) {
+ if (has_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->name().data(), this->name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -10961,9 +10983,9 @@ void setxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->name(), target);
}
-
+
// required string value = 4;
- if (_has_bit(3)) {
+ if (has_value()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->value().data(), this->value().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -10971,19 +10993,19 @@ void setxattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->value(), target);
}
-
+
// required fixed32 flags = 5;
- if (_has_bit(5)) {
+ if (has_flags()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->flags(), target);
}
-
- // optional bytes value_bytes = 6;
- if (_has_bit(4)) {
+
+ // optional bytes value_bytes_string = 6;
+ if (has_value_bytes_string()) {
target =
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
- 6, this->value_bytes(), target);
+ 6, this->value_bytes_string(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -10993,7 +11015,7 @@ void setxattrRequest::SerializeWithCachedSizes(
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()) {
@@ -11001,40 +11023,40 @@ int setxattrRequest::ByteSize() const {
::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 = 6;
- if (has_value_bytes()) {
+
+ // optional bytes value_bytes_string = 6;
+ if (has_value_bytes_string()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
- this->value_bytes());
+ this->value_bytes_string());
}
-
+
// required fixed32 flags = 5;
if (has_flags()) {
total_size += 1 + 4;
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -11062,22 +11084,22 @@ void setxattrRequest::MergeFrom(const ::google::protobuf::Message& from) {
void setxattrRequest::MergeFrom(const setxattrRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_name()) {
set_name(from.name());
}
- if (from._has_bit(3)) {
+ if (from.has_value()) {
set_value(from.value());
}
- if (from._has_bit(4)) {
- set_value_bytes(from.value_bytes());
+ if (from.has_value_bytes_string()) {
+ set_value_bytes_string(from.value_bytes_string());
}
- if (from._has_bit(5)) {
+ if (from.has_flags()) {
set_flags(from.flags());
}
}
@@ -11098,7 +11120,7 @@ void setxattrRequest::CopyFrom(const setxattrRequest& from) {
bool setxattrRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x0000002f) != 0x0000002f) return false;
-
+
return true;
}
@@ -11108,7 +11130,7 @@ void setxattrRequest::Swap(setxattrRequest* other) {
std::swap(path_, other->path_);
std::swap(name_, other->name_);
std::swap(value_, other->value_);
- std::swap(value_bytes_, other->value_bytes_);
+ 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_);
@@ -11127,7 +11149,6 @@ void setxattrRequest::Swap(setxattrRequest* other) {
// ===================================================================
-const ::std::string statvfsRequest::_default_volume_name_;
#ifndef _MSC_VER
const int statvfsRequest::kVolumeNameFieldNumber;
const int statvfsRequest::kKnownEtagFieldNumber;
@@ -11149,7 +11170,7 @@ statvfsRequest::statvfsRequest(const statvfsRequest& from)
void statvfsRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
+ volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
known_etag_ = GOOGLE_ULONGLONG(0);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -11159,7 +11180,7 @@ statvfsRequest::~statvfsRequest() {
}
void statvfsRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
if (this != default_instance_) {
@@ -11177,7 +11198,8 @@ const ::google::protobuf::Descriptor* statvfsRequest::descriptor() {
}
const statvfsRequest& statvfsRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
statvfsRequest* statvfsRequest::default_instance_ = NULL;
@@ -11188,8 +11210,8 @@ statvfsRequest* statvfsRequest::New() const {
void statvfsRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
@@ -11220,7 +11242,7 @@ bool statvfsRequest::MergePartialFromCodedStream(
if (input->ExpectTag(41)) goto parse_known_etag;
break;
}
-
+
// required fixed64 known_etag = 5;
case 5: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -11229,14 +11251,14 @@ bool statvfsRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &known_etag_)));
- _set_bit(1);
+ set_has_known_etag();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -11256,19 +11278,19 @@ bool statvfsRequest::MergePartialFromCodedStream(
void statvfsRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ 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);
@@ -11278,7 +11300,7 @@ void statvfsRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* statvfsRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -11286,12 +11308,12 @@ void statvfsRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required fixed64 known_etag = 5;
- if (_has_bit(1)) {
+ 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);
@@ -11301,7 +11323,7 @@ void statvfsRequest::SerializeWithCachedSizes(
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()) {
@@ -11309,12 +11331,12 @@ int statvfsRequest::ByteSize() const {
::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 +=
@@ -11342,10 +11364,10 @@ void statvfsRequest::MergeFrom(const ::google::protobuf::Message& from) {
void statvfsRequest::MergeFrom(const statvfsRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_known_etag()) {
set_known_etag(from.known_etag());
}
}
@@ -11366,7 +11388,7 @@ void statvfsRequest::CopyFrom(const statvfsRequest& from) {
bool statvfsRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
@@ -11391,9 +11413,6 @@ void statvfsRequest::Swap(statvfsRequest* other) {
// ===================================================================
-const ::std::string symlinkRequest::_default_volume_name_;
-const ::std::string symlinkRequest::_default_target_path_;
-const ::std::string symlinkRequest::_default_link_path_;
#ifndef _MSC_VER
const int symlinkRequest::kVolumeNameFieldNumber;
const int symlinkRequest::kTargetPathFieldNumber;
@@ -11416,9 +11435,9 @@ symlinkRequest::symlinkRequest(const symlinkRequest& from)
void symlinkRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- target_path_ = const_cast< ::std::string*>(&_default_target_path_);
- link_path_ = const_cast< ::std::string*>(&_default_link_path_);
+ 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_));
}
@@ -11427,13 +11446,13 @@ symlinkRequest::~symlinkRequest() {
}
void symlinkRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (target_path_ != &_default_target_path_) {
+ if (target_path_ != &::google::protobuf::internal::kEmptyString) {
delete target_path_;
}
- if (link_path_ != &_default_link_path_) {
+ if (link_path_ != &::google::protobuf::internal::kEmptyString) {
delete link_path_;
}
if (this != default_instance_) {
@@ -11451,7 +11470,8 @@ const ::google::protobuf::Descriptor* symlinkRequest::descriptor() {
}
const symlinkRequest& symlinkRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
symlinkRequest* symlinkRequest::default_instance_ = NULL;
@@ -11462,18 +11482,18 @@ symlinkRequest* symlinkRequest::New() const {
void symlinkRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (target_path_ != &_default_target_path_) {
+ if (has_target_path()) {
+ if (target_path_ != &::google::protobuf::internal::kEmptyString) {
target_path_->clear();
}
}
- if (_has_bit(2)) {
- if (link_path_ != &_default_link_path_) {
+ if (has_link_path()) {
+ if (link_path_ != &::google::protobuf::internal::kEmptyString) {
link_path_->clear();
}
}
@@ -11503,7 +11523,7 @@ bool symlinkRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_target_path;
break;
}
-
+
// required string target_path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -11520,7 +11540,7 @@ bool symlinkRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_link_path;
break;
}
-
+
// required string link_path = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -11537,7 +11557,7 @@ bool symlinkRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -11557,32 +11577,32 @@ bool symlinkRequest::MergePartialFromCodedStream(
void symlinkRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ 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_bit(2)) {
+ 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);
@@ -11592,7 +11612,7 @@ void symlinkRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* symlinkRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -11600,9 +11620,9 @@ void symlinkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string target_path = 2;
- if (_has_bit(1)) {
+ if (has_target_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->target_path().data(), this->target_path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -11610,9 +11630,9 @@ void symlinkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->target_path(), target);
}
-
+
// required string link_path = 3;
- if (_has_bit(2)) {
+ if (has_link_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->link_path().data(), this->link_path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -11620,7 +11640,7 @@ void symlinkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->link_path(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -11630,7 +11650,7 @@ void symlinkRequest::SerializeWithCachedSizes(
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()) {
@@ -11638,21 +11658,21 @@ int symlinkRequest::ByteSize() const {
::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 +=
@@ -11680,13 +11700,13 @@ void symlinkRequest::MergeFrom(const ::google::protobuf::Message& from) {
void symlinkRequest::MergeFrom(const symlinkRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_target_path()) {
set_target_path(from.target_path());
}
- if (from._has_bit(2)) {
+ if (from.has_link_path()) {
set_link_path(from.link_path());
}
}
@@ -11707,7 +11727,7 @@ void symlinkRequest::CopyFrom(const symlinkRequest& from) {
bool symlinkRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -11733,8 +11753,6 @@ void symlinkRequest::Swap(symlinkRequest* other) {
// ===================================================================
-const ::std::string unlinkRequest::_default_volume_name_;
-const ::std::string unlinkRequest::_default_path_;
#ifndef _MSC_VER
const int unlinkRequest::kVolumeNameFieldNumber;
const int unlinkRequest::kPathFieldNumber;
@@ -11756,8 +11774,8 @@ unlinkRequest::unlinkRequest(const unlinkRequest& from)
void unlinkRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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_));
}
@@ -11766,10 +11784,10 @@ unlinkRequest::~unlinkRequest() {
}
void unlinkRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -11787,7 +11805,8 @@ const ::google::protobuf::Descriptor* unlinkRequest::descriptor() {
}
const unlinkRequest& unlinkRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
unlinkRequest* unlinkRequest::default_instance_ = NULL;
@@ -11798,13 +11817,13 @@ unlinkRequest* unlinkRequest::New() const {
void unlinkRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -11834,7 +11853,7 @@ bool unlinkRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -11851,7 +11870,7 @@ bool unlinkRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -11871,23 +11890,23 @@ bool unlinkRequest::MergePartialFromCodedStream(
void unlinkRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -11897,7 +11916,7 @@ void unlinkRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* unlinkRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -11905,9 +11924,9 @@ void unlinkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -11915,7 +11934,7 @@ void unlinkRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -11925,7 +11944,7 @@ void unlinkRequest::SerializeWithCachedSizes(
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()) {
@@ -11933,14 +11952,14 @@ int unlinkRequest::ByteSize() const {
::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 +=
@@ -11968,10 +11987,10 @@ void unlinkRequest::MergeFrom(const ::google::protobuf::Message& from) {
void unlinkRequest::MergeFrom(const unlinkRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
}
@@ -11992,7 +12011,7 @@ void unlinkRequest::CopyFrom(const unlinkRequest& from) {
bool unlinkRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
@@ -12065,7 +12084,8 @@ const ::google::protobuf::Descriptor* unlinkResponse::descriptor() {
}
const unlinkResponse& unlinkResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
unlinkResponse* unlinkResponse::default_instance_ = NULL;
@@ -12077,7 +12097,7 @@ unlinkResponse* unlinkResponse::New() const {
void unlinkResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
timestamp_s_ = 0u;
- if (_has_bit(1)) {
+ if (has_creds()) {
if (creds_ != NULL) creds_->::xtreemfs::pbrpc::FileCredentials::Clear();
}
}
@@ -12098,14 +12118,14 @@ bool unlinkResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, ×tamp_s_)));
- _set_bit(0);
+ 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) ==
@@ -12119,7 +12139,7 @@ bool unlinkResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -12139,16 +12159,16 @@ bool unlinkResponse::MergePartialFromCodedStream(
void unlinkResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed32 timestamp_s = 1;
- if (_has_bit(0)) {
+ if (has_timestamp_s()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->timestamp_s(), output);
}
-
+
// optional .xtreemfs.pbrpc.FileCredentials creds = 2;
- if (_has_bit(1)) {
+ if (has_creds()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->creds(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -12158,17 +12178,17 @@ void unlinkResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* unlinkResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed32 timestamp_s = 1;
- if (_has_bit(0)) {
+ if (has_timestamp_s()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->timestamp_s(), target);
}
-
+
// optional .xtreemfs.pbrpc.FileCredentials creds = 2;
- if (_has_bit(1)) {
+ 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);
@@ -12178,20 +12198,20 @@ void unlinkResponse::SerializeWithCachedSizes(
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 +=
@@ -12219,10 +12239,10 @@ void unlinkResponse::MergeFrom(const ::google::protobuf::Message& from) {
void unlinkResponse::MergeFrom(const unlinkResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_timestamp_s()) {
set_timestamp_s(from.timestamp_s());
}
- if (from._has_bit(1)) {
+ if (from.has_creds()) {
mutable_creds()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.creds());
}
}
@@ -12243,7 +12263,7 @@ void unlinkResponse::CopyFrom(const unlinkResponse& from) {
bool unlinkResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
if (has_creds()) {
if (!this->creds().IsInitialized()) return false;
}
@@ -12271,8 +12291,6 @@ void unlinkResponse::Swap(unlinkResponse* other) {
// ===================================================================
-const ::std::string accessRequest::_default_volume_name_;
-const ::std::string accessRequest::_default_path_;
#ifndef _MSC_VER
const int accessRequest::kVolumeNameFieldNumber;
const int accessRequest::kPathFieldNumber;
@@ -12295,8 +12313,8 @@ accessRequest::accessRequest(const accessRequest& from)
void accessRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- path_ = const_cast< ::std::string*>(&_default_path_);
+ 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_));
}
@@ -12306,10 +12324,10 @@ accessRequest::~accessRequest() {
}
void accessRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -12327,7 +12345,8 @@ const ::google::protobuf::Descriptor* accessRequest::descriptor() {
}
const accessRequest& accessRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
accessRequest* accessRequest::default_instance_ = NULL;
@@ -12338,13 +12357,13 @@ accessRequest* accessRequest::New() const {
void accessRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -12375,7 +12394,7 @@ bool accessRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// required string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -12392,7 +12411,7 @@ bool accessRequest::MergePartialFromCodedStream(
if (input->ExpectTag(29)) goto parse_flags;
break;
}
-
+
// required fixed32 flags = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -12401,14 +12420,14 @@ bool accessRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &flags_)));
- _set_bit(2);
+ set_has_flags();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -12428,28 +12447,28 @@ bool accessRequest::MergePartialFromCodedStream(
void accessRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// required fixed32 flags = 3;
- if (_has_bit(2)) {
+ if (has_flags()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->flags(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -12459,7 +12478,7 @@ void accessRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* accessRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -12467,9 +12486,9 @@ void accessRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
// required string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -12477,12 +12496,12 @@ void accessRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// required fixed32 flags = 3;
- if (_has_bit(2)) {
+ 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);
@@ -12492,7 +12511,7 @@ void accessRequest::SerializeWithCachedSizes(
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()) {
@@ -12500,19 +12519,19 @@ int accessRequest::ByteSize() const {
::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 +=
@@ -12540,13 +12559,13 @@ void accessRequest::MergeFrom(const ::google::protobuf::Message& from) {
void accessRequest::MergeFrom(const accessRequest& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_flags()) {
set_flags(from.flags());
}
}
@@ -12567,7 +12586,7 @@ void accessRequest::CopyFrom(const accessRequest& from) {
bool accessRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
-
+
return true;
}
@@ -12593,8 +12612,6 @@ void accessRequest::Swap(accessRequest* other) {
// ===================================================================
-const ::std::string xtreemfs_check_file_existsRequest::_default_volume_id_;
-const ::std::string xtreemfs_check_file_existsRequest::_default_osd_uuid_;
#ifndef _MSC_VER
const int xtreemfs_check_file_existsRequest::kVolumeIdFieldNumber;
const int xtreemfs_check_file_existsRequest::kFileIdsFieldNumber;
@@ -12617,8 +12634,8 @@ xtreemfs_check_file_existsRequest::xtreemfs_check_file_existsRequest(const xtree
void xtreemfs_check_file_existsRequest::SharedCtor() {
_cached_size_ = 0;
- volume_id_ = const_cast< ::std::string*>(&_default_volume_id_);
- osd_uuid_ = const_cast< ::std::string*>(&_default_osd_uuid_);
+ 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_));
}
@@ -12627,10 +12644,10 @@ xtreemfs_check_file_existsRequest::~xtreemfs_check_file_existsRequest() {
}
void xtreemfs_check_file_existsRequest::SharedDtor() {
- if (volume_id_ != &_default_volume_id_) {
+ if (volume_id_ != &::google::protobuf::internal::kEmptyString) {
delete volume_id_;
}
- if (osd_uuid_ != &_default_osd_uuid_) {
+ if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) {
delete osd_uuid_;
}
if (this != default_instance_) {
@@ -12648,7 +12665,8 @@ const ::google::protobuf::Descriptor* xtreemfs_check_file_existsRequest::descrip
}
const xtreemfs_check_file_existsRequest& xtreemfs_check_file_existsRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *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;
@@ -12659,13 +12677,13 @@ xtreemfs_check_file_existsRequest* xtreemfs_check_file_existsRequest::New() cons
void xtreemfs_check_file_existsRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_id_ != &_default_volume_id_) {
+ if (has_volume_id()) {
+ if (volume_id_ != &::google::protobuf::internal::kEmptyString) {
volume_id_->clear();
}
}
- if (_has_bit(2)) {
- if (osd_uuid_ != &_default_osd_uuid_) {
+ if (has_osd_uuid()) {
+ if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) {
osd_uuid_->clear();
}
}
@@ -12696,7 +12714,7 @@ bool xtreemfs_check_file_existsRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_file_ids;
break;
}
-
+
// repeated string file_ids = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -12705,7 +12723,8 @@ bool xtreemfs_check_file_existsRequest::MergePartialFromCodedStream(
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->add_file_ids()));
::google::protobuf::internal::WireFormat::VerifyUTF8String(
- this->file_ids(0).data(), this->file_ids(0).length(),
+ 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;
@@ -12714,7 +12733,7 @@ bool xtreemfs_check_file_existsRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_osd_uuid;
break;
}
-
+
// required string osd_uuid = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -12731,7 +12750,7 @@ bool xtreemfs_check_file_existsRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -12751,14 +12770,14 @@ bool xtreemfs_check_file_existsRequest::MergePartialFromCodedStream(
void xtreemfs_check_file_existsRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_id = 1;
- if (_has_bit(0)) {
+ 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(
@@ -12767,16 +12786,16 @@ void xtreemfs_check_file_existsRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteString(
2, this->file_ids(i), output);
}
-
+
// required string osd_uuid = 3;
- if (_has_bit(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(
3, this->osd_uuid(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -12786,7 +12805,7 @@ void xtreemfs_check_file_existsRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_check_file_existsRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_id = 1;
- if (_has_bit(0)) {
+ if (has_volume_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_id().data(), this->volume_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -12794,7 +12813,7 @@ void xtreemfs_check_file_existsRequest::SerializeWithCachedSizes(
::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(
@@ -12803,9 +12822,9 @@ void xtreemfs_check_file_existsRequest::SerializeWithCachedSizes(
target = ::google::protobuf::internal::WireFormatLite::
WriteStringToArray(2, this->file_ids(i), target);
}
-
+
// required string osd_uuid = 3;
- if (_has_bit(2)) {
+ if (has_osd_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->osd_uuid().data(), this->osd_uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -12813,7 +12832,7 @@ void xtreemfs_check_file_existsRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->osd_uuid(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -12823,7 +12842,7 @@ void xtreemfs_check_file_existsRequest::SerializeWithCachedSizes(
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()) {
@@ -12831,14 +12850,14 @@ int xtreemfs_check_file_existsRequest::ByteSize() const {
::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();
@@ -12846,7 +12865,7 @@ int xtreemfs_check_file_existsRequest::ByteSize() const {
total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
this->file_ids(i));
}
-
+
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -12874,10 +12893,10 @@ void xtreemfs_check_file_existsRequest::MergeFrom(const xtreemfs_check_file_exis
GOOGLE_CHECK_NE(&from, this);
file_ids_.MergeFrom(from.file_ids_);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_volume_id()) {
set_volume_id(from.volume_id());
}
- if (from._has_bit(2)) {
+ if (from.has_osd_uuid()) {
set_osd_uuid(from.osd_uuid());
}
}
@@ -12898,7 +12917,7 @@ void xtreemfs_check_file_existsRequest::CopyFrom(const xtreemfs_check_file_exist
bool xtreemfs_check_file_existsRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
-
+
return true;
}
@@ -12924,7 +12943,6 @@ void xtreemfs_check_file_existsRequest::Swap(xtreemfs_check_file_existsRequest*
// ===================================================================
-const ::std::string xtreemfs_dump_restore_databaseRequest::_default_dump_file_;
#ifndef _MSC_VER
const int xtreemfs_dump_restore_databaseRequest::kDumpFileFieldNumber;
#endif // !_MSC_VER
@@ -12945,7 +12963,7 @@ xtreemfs_dump_restore_databaseRequest::xtreemfs_dump_restore_databaseRequest(con
void xtreemfs_dump_restore_databaseRequest::SharedCtor() {
_cached_size_ = 0;
- dump_file_ = const_cast< ::std::string*>(&_default_dump_file_);
+ dump_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -12954,7 +12972,7 @@ xtreemfs_dump_restore_databaseRequest::~xtreemfs_dump_restore_databaseRequest()
}
void xtreemfs_dump_restore_databaseRequest::SharedDtor() {
- if (dump_file_ != &_default_dump_file_) {
+ if (dump_file_ != &::google::protobuf::internal::kEmptyString) {
delete dump_file_;
}
if (this != default_instance_) {
@@ -12972,7 +12990,8 @@ const ::google::protobuf::Descriptor* xtreemfs_dump_restore_databaseRequest::des
}
const xtreemfs_dump_restore_databaseRequest& xtreemfs_dump_restore_databaseRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *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;
@@ -12983,8 +13002,8 @@ xtreemfs_dump_restore_databaseRequest* xtreemfs_dump_restore_databaseRequest::Ne
void xtreemfs_dump_restore_databaseRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (dump_file_ != &_default_dump_file_) {
+ if (has_dump_file()) {
+ if (dump_file_ != &::google::protobuf::internal::kEmptyString) {
dump_file_->clear();
}
}
@@ -13014,7 +13033,7 @@ bool xtreemfs_dump_restore_databaseRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -13034,14 +13053,14 @@ bool xtreemfs_dump_restore_databaseRequest::MergePartialFromCodedStream(
void xtreemfs_dump_restore_databaseRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string dump_file = 1;
- if (_has_bit(0)) {
+ 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);
@@ -13051,7 +13070,7 @@ void xtreemfs_dump_restore_databaseRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_dump_restore_databaseRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string dump_file = 1;
- if (_has_bit(0)) {
+ if (has_dump_file()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->dump_file().data(), this->dump_file().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -13059,7 +13078,7 @@ void xtreemfs_dump_restore_databaseRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->dump_file(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -13069,7 +13088,7 @@ void xtreemfs_dump_restore_databaseRequest::SerializeWithCachedSizes(
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()) {
@@ -13077,7 +13096,7 @@ int xtreemfs_dump_restore_databaseRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->dump_file());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -13105,7 +13124,7 @@ void xtreemfs_dump_restore_databaseRequest::MergeFrom(const ::google::protobuf::
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_bit(0)) {
+ if (from.has_dump_file()) {
set_dump_file(from.dump_file());
}
}
@@ -13126,7 +13145,7 @@ void xtreemfs_dump_restore_databaseRequest::CopyFrom(const xtreemfs_dump_restore
bool xtreemfs_dump_restore_databaseRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -13150,9 +13169,6 @@ void xtreemfs_dump_restore_databaseRequest::Swap(xtreemfs_dump_restore_databaseR
// ===================================================================
-const ::std::string xtreemfs_get_suitable_osdsRequest::_default_file_id_;
-const ::std::string xtreemfs_get_suitable_osdsRequest::_default_path_;
-const ::std::string xtreemfs_get_suitable_osdsRequest::_default_volume_name_;
#ifndef _MSC_VER
const int xtreemfs_get_suitable_osdsRequest::kFileIdFieldNumber;
const int xtreemfs_get_suitable_osdsRequest::kPathFieldNumber;
@@ -13176,9 +13192,9 @@ xtreemfs_get_suitable_osdsRequest::xtreemfs_get_suitable_osdsRequest(const xtree
void xtreemfs_get_suitable_osdsRequest::SharedCtor() {
_cached_size_ = 0;
- file_id_ = const_cast< ::std::string*>(&_default_file_id_);
- path_ = const_cast< ::std::string*>(&_default_path_);
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
+ 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_));
}
@@ -13188,13 +13204,13 @@ xtreemfs_get_suitable_osdsRequest::~xtreemfs_get_suitable_osdsRequest() {
}
void xtreemfs_get_suitable_osdsRequest::SharedDtor() {
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
if (this != default_instance_) {
@@ -13212,7 +13228,8 @@ const ::google::protobuf::Descriptor* xtreemfs_get_suitable_osdsRequest::descrip
}
const xtreemfs_get_suitable_osdsRequest& xtreemfs_get_suitable_osdsRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *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;
@@ -13223,18 +13240,18 @@ xtreemfs_get_suitable_osdsRequest* xtreemfs_get_suitable_osdsRequest::New() cons
void xtreemfs_get_suitable_osdsRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
- if (_has_bit(2)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
@@ -13265,7 +13282,7 @@ bool xtreemfs_get_suitable_osdsRequest::MergePartialFromCodedStream(
if (input->ExpectTag(21)) goto parse_num_osds;
break;
}
-
+
// required fixed32 num_osds = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -13274,14 +13291,14 @@ bool xtreemfs_get_suitable_osdsRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &num_osds_)));
- _set_bit(3);
+ 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) ==
@@ -13298,7 +13315,7 @@ bool xtreemfs_get_suitable_osdsRequest::MergePartialFromCodedStream(
if (input->ExpectTag(34)) goto parse_volume_name;
break;
}
-
+
// optional string volume_name = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -13315,7 +13332,7 @@ bool xtreemfs_get_suitable_osdsRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -13335,37 +13352,37 @@ bool xtreemfs_get_suitable_osdsRequest::MergePartialFromCodedStream(
void xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional string file_id = 1;
- if (_has_bit(0)) {
+ 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_bit(3)) {
+ if (has_num_osds()) {
::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->num_osds(), output);
}
-
+
// optional string path = 3;
- if (_has_bit(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(
3, this->path(), output);
}
-
+
// optional string volume_name = 4;
- if (_has_bit(2)) {
+ 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);
@@ -13375,7 +13392,7 @@ void xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional string file_id = 1;
- if (_has_bit(0)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -13383,14 +13400,14 @@ void xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->file_id(), target);
}
-
+
// required fixed32 num_osds = 2;
- if (_has_bit(3)) {
+ if (has_num_osds()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->num_osds(), target);
}
-
+
// optional string path = 3;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -13398,9 +13415,9 @@ void xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->path(), target);
}
-
+
// optional string volume_name = 4;
- if (_has_bit(2)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -13408,7 +13425,7 @@ void xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->volume_name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -13418,7 +13435,7 @@ void xtreemfs_get_suitable_osdsRequest::SerializeWithCachedSizes(
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()) {
@@ -13426,26 +13443,26 @@ int xtreemfs_get_suitable_osdsRequest::ByteSize() const {
::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 +=
@@ -13473,16 +13490,16 @@ void xtreemfs_get_suitable_osdsRequest::MergeFrom(const ::google::protobuf::Mess
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_bit(0)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(3)) {
+ if (from.has_num_osds()) {
set_num_osds(from.num_osds());
}
}
@@ -13503,7 +13520,7 @@ void xtreemfs_get_suitable_osdsRequest::CopyFrom(const xtreemfs_get_suitable_osd
bool xtreemfs_get_suitable_osdsRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false;
-
+
return true;
}
@@ -13573,7 +13590,8 @@ const ::google::protobuf::Descriptor* xtreemfs_get_suitable_osdsResponse::descri
}
const xtreemfs_get_suitable_osdsResponse& xtreemfs_get_suitable_osdsResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *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;
@@ -13602,7 +13620,8 @@ bool xtreemfs_get_suitable_osdsResponse::MergePartialFromCodedStream(
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->add_osd_uuids()));
::google::protobuf::internal::WireFormat::VerifyUTF8String(
- this->osd_uuids(0).data(), this->osd_uuids(0).length(),
+ 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;
@@ -13611,7 +13630,7 @@ bool xtreemfs_get_suitable_osdsResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -13638,7 +13657,7 @@ void xtreemfs_get_suitable_osdsResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteString(
1, this->osd_uuids(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -13655,7 +13674,7 @@ void xtreemfs_get_suitable_osdsResponse::SerializeWithCachedSizes(
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);
@@ -13665,14 +13684,14 @@ void xtreemfs_get_suitable_osdsResponse::SerializeWithCachedSizes(
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(
@@ -13715,7 +13734,7 @@ void xtreemfs_get_suitable_osdsResponse::CopyFrom(const xtreemfs_get_suitable_os
}
bool xtreemfs_get_suitable_osdsResponse::IsInitialized() const {
-
+
return true;
}
@@ -13739,7 +13758,6 @@ void xtreemfs_get_suitable_osdsResponse::Swap(xtreemfs_get_suitable_osdsResponse
// ===================================================================
-const ::std::string xtreemfs_check_file_existsResponse::_default_bitmap_;
#ifndef _MSC_VER
const int xtreemfs_check_file_existsResponse::kBitmapFieldNumber;
#endif // !_MSC_VER
@@ -13760,7 +13778,7 @@ xtreemfs_check_file_existsResponse::xtreemfs_check_file_existsResponse(const xtr
void xtreemfs_check_file_existsResponse::SharedCtor() {
_cached_size_ = 0;
- bitmap_ = const_cast< ::std::string*>(&_default_bitmap_);
+ bitmap_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -13769,7 +13787,7 @@ xtreemfs_check_file_existsResponse::~xtreemfs_check_file_existsResponse() {
}
void xtreemfs_check_file_existsResponse::SharedDtor() {
- if (bitmap_ != &_default_bitmap_) {
+ if (bitmap_ != &::google::protobuf::internal::kEmptyString) {
delete bitmap_;
}
if (this != default_instance_) {
@@ -13787,7 +13805,8 @@ const ::google::protobuf::Descriptor* xtreemfs_check_file_existsResponse::descri
}
const xtreemfs_check_file_existsResponse& xtreemfs_check_file_existsResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *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;
@@ -13798,8 +13817,8 @@ xtreemfs_check_file_existsResponse* xtreemfs_check_file_existsResponse::New() co
void xtreemfs_check_file_existsResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (bitmap_ != &_default_bitmap_) {
+ if (has_bitmap()) {
+ if (bitmap_ != &::google::protobuf::internal::kEmptyString) {
bitmap_->clear();
}
}
@@ -13829,7 +13848,7 @@ bool xtreemfs_check_file_existsResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -13849,14 +13868,14 @@ bool xtreemfs_check_file_existsResponse::MergePartialFromCodedStream(
void xtreemfs_check_file_existsResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string bitmap = 1;
- if (_has_bit(0)) {
+ if (has_bitmap()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->bitmap().data(), this->bitmap().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
::google::protobuf::internal::WireFormatLite::WriteString(
1, this->bitmap(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -13866,7 +13885,7 @@ void xtreemfs_check_file_existsResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_check_file_existsResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string bitmap = 1;
- if (_has_bit(0)) {
+ if (has_bitmap()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->bitmap().data(), this->bitmap().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -13874,7 +13893,7 @@ void xtreemfs_check_file_existsResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->bitmap(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -13884,7 +13903,7 @@ void xtreemfs_check_file_existsResponse::SerializeWithCachedSizes(
int xtreemfs_check_file_existsResponse::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string bitmap = 1;
if (has_bitmap()) {
@@ -13892,7 +13911,7 @@ int xtreemfs_check_file_existsResponse::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->bitmap());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -13920,7 +13939,7 @@ void xtreemfs_check_file_existsResponse::MergeFrom(const ::google::protobuf::Mes
void xtreemfs_check_file_existsResponse::MergeFrom(const xtreemfs_check_file_existsResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_bitmap()) {
set_bitmap(from.bitmap());
}
}
@@ -13941,7 +13960,7 @@ void xtreemfs_check_file_existsResponse::CopyFrom(const xtreemfs_check_file_exis
bool xtreemfs_check_file_existsResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -14009,7 +14028,8 @@ const ::google::protobuf::Descriptor* timestampResponse::descriptor() {
}
const timestampResponse& timestampResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
timestampResponse* timestampResponse::default_instance_ = NULL;
@@ -14039,14 +14059,14 @@ bool timestampResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, ×tamp_s_)));
- _set_bit(0);
+ set_has_timestamp_s();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -14066,10 +14086,10 @@ bool timestampResponse::MergePartialFromCodedStream(
void timestampResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required fixed32 timestamp_s = 1;
- if (_has_bit(0)) {
+ 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);
@@ -14079,10 +14099,10 @@ void timestampResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* timestampResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required fixed32 timestamp_s = 1;
- if (_has_bit(0)) {
+ 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);
@@ -14092,13 +14112,13 @@ void timestampResponse::SerializeWithCachedSizes(
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 +=
@@ -14126,7 +14146,7 @@ void timestampResponse::MergeFrom(const ::google::protobuf::Message& from) {
void timestampResponse::MergeFrom(const timestampResponse& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_timestamp_s()) {
set_timestamp_s(from.timestamp_s());
}
}
@@ -14147,7 +14167,7 @@ void timestampResponse::CopyFrom(const timestampResponse& from) {
bool timestampResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -14171,7 +14191,6 @@ void timestampResponse::Swap(timestampResponse* other) {
// ===================================================================
-const ::std::string stringMessage::_default_a_string_;
#ifndef _MSC_VER
const int stringMessage::kAStringFieldNumber;
#endif // !_MSC_VER
@@ -14192,7 +14211,7 @@ stringMessage::stringMessage(const stringMessage& from)
void stringMessage::SharedCtor() {
_cached_size_ = 0;
- a_string_ = const_cast< ::std::string*>(&_default_a_string_);
+ a_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -14201,7 +14220,7 @@ stringMessage::~stringMessage() {
}
void stringMessage::SharedDtor() {
- if (a_string_ != &_default_a_string_) {
+ if (a_string_ != &::google::protobuf::internal::kEmptyString) {
delete a_string_;
}
if (this != default_instance_) {
@@ -14219,7 +14238,8 @@ const ::google::protobuf::Descriptor* stringMessage::descriptor() {
}
const stringMessage& stringMessage::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
stringMessage* stringMessage::default_instance_ = NULL;
@@ -14230,8 +14250,8 @@ stringMessage* stringMessage::New() const {
void stringMessage::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (a_string_ != &_default_a_string_) {
+ if (has_a_string()) {
+ if (a_string_ != &::google::protobuf::internal::kEmptyString) {
a_string_->clear();
}
}
@@ -14261,7 +14281,7 @@ bool stringMessage::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -14281,14 +14301,14 @@ bool stringMessage::MergePartialFromCodedStream(
void stringMessage::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string a_string = 1;
- if (_has_bit(0)) {
+ 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);
@@ -14298,7 +14318,7 @@ void stringMessage::SerializeWithCachedSizes(
::google::protobuf::uint8* stringMessage::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string a_string = 1;
- if (_has_bit(0)) {
+ if (has_a_string()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->a_string().data(), this->a_string().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -14306,7 +14326,7 @@ void stringMessage::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->a_string(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -14316,7 +14336,7 @@ void stringMessage::SerializeWithCachedSizes(
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()) {
@@ -14324,7 +14344,7 @@ int stringMessage::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->a_string());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -14352,7 +14372,7 @@ void stringMessage::MergeFrom(const ::google::protobuf::Message& from) {
void stringMessage::MergeFrom(const stringMessage& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (from._has_bit(0)) {
+ if (from.has_a_string()) {
set_a_string(from.a_string());
}
}
@@ -14373,7 +14393,7 @@ void stringMessage::CopyFrom(const stringMessage& from) {
bool stringMessage::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -14397,7 +14417,6 @@ void stringMessage::Swap(stringMessage* other) {
// ===================================================================
-const ::std::string xtreemfs_listdirRequest::_default_path_;
#ifndef _MSC_VER
const int xtreemfs_listdirRequest::kPathFieldNumber;
#endif // !_MSC_VER
@@ -14418,7 +14437,7 @@ xtreemfs_listdirRequest::xtreemfs_listdirRequest(const xtreemfs_listdirRequest&
void xtreemfs_listdirRequest::SharedCtor() {
_cached_size_ = 0;
- path_ = const_cast< ::std::string*>(&_default_path_);
+ path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -14427,7 +14446,7 @@ xtreemfs_listdirRequest::~xtreemfs_listdirRequest() {
}
void xtreemfs_listdirRequest::SharedDtor() {
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
if (this != default_instance_) {
@@ -14445,7 +14464,8 @@ const ::google::protobuf::Descriptor* xtreemfs_listdirRequest::descriptor() {
}
const xtreemfs_listdirRequest& xtreemfs_listdirRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
xtreemfs_listdirRequest* xtreemfs_listdirRequest::default_instance_ = NULL;
@@ -14456,8 +14476,8 @@ xtreemfs_listdirRequest* xtreemfs_listdirRequest::New() const {
void xtreemfs_listdirRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
@@ -14487,7 +14507,7 @@ bool xtreemfs_listdirRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -14507,14 +14527,14 @@ bool xtreemfs_listdirRequest::MergePartialFromCodedStream(
void xtreemfs_listdirRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string path = 1;
- if (_has_bit(0)) {
+ 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);
@@ -14524,7 +14544,7 @@ void xtreemfs_listdirRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_listdirRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string path = 1;
- if (_has_bit(0)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -14532,7 +14552,7 @@ void xtreemfs_listdirRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->path(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -14542,7 +14562,7 @@ void xtreemfs_listdirRequest::SerializeWithCachedSizes(
int xtreemfs_listdirRequest::ByteSize() const {
int total_size = 0;
-
+
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string path = 1;
if (has_path()) {
@@ -14550,7 +14570,7 @@ int xtreemfs_listdirRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->path());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -14578,7 +14598,7 @@ void xtreemfs_listdirRequest::MergeFrom(const ::google::protobuf::Message& from)
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_bit(0)) {
+ if (from.has_path()) {
set_path(from.path());
}
}
@@ -14599,7 +14619,7 @@ void xtreemfs_listdirRequest::CopyFrom(const xtreemfs_listdirRequest& from) {
bool xtreemfs_listdirRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -14666,7 +14686,8 @@ const ::google::protobuf::Descriptor* xtreemfs_listdirResponse::descriptor() {
}
const xtreemfs_listdirResponse& xtreemfs_listdirResponse::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
xtreemfs_listdirResponse* xtreemfs_listdirResponse::default_instance_ = NULL;
@@ -14695,7 +14716,8 @@ bool xtreemfs_listdirResponse::MergePartialFromCodedStream(
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->add_names()));
::google::protobuf::internal::WireFormat::VerifyUTF8String(
- this->names(0).data(), this->names(0).length(),
+ this->names(this->names_size() - 1).data(),
+ this->names(this->names_size() - 1).length(),
::google::protobuf::internal::WireFormat::PARSE);
} else {
goto handle_uninterpreted;
@@ -14704,7 +14726,7 @@ bool xtreemfs_listdirResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -14731,7 +14753,7 @@ void xtreemfs_listdirResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteString(
1, this->names(i), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -14748,7 +14770,7 @@ void xtreemfs_listdirResponse::SerializeWithCachedSizes(
target = ::google::protobuf::internal::WireFormatLite::
WriteStringToArray(1, this->names(i), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -14758,14 +14780,14 @@ void xtreemfs_listdirResponse::SerializeWithCachedSizes(
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(
@@ -14808,7 +14830,7 @@ void xtreemfs_listdirResponse::CopyFrom(const xtreemfs_listdirResponse& from) {
}
bool xtreemfs_listdirResponse::IsInitialized() const {
-
+
return true;
}
@@ -14832,9 +14854,6 @@ void xtreemfs_listdirResponse::Swap(xtreemfs_listdirResponse* other) {
// ===================================================================
-const ::std::string xtreemfs_replica_addRequest::_default_file_id_;
-const ::std::string xtreemfs_replica_addRequest::_default_path_;
-const ::std::string xtreemfs_replica_addRequest::_default_volume_name_;
#ifndef _MSC_VER
const int xtreemfs_replica_addRequest::kFileIdFieldNumber;
const int xtreemfs_replica_addRequest::kPathFieldNumber;
@@ -14859,9 +14878,9 @@ xtreemfs_replica_addRequest::xtreemfs_replica_addRequest(const xtreemfs_replica_
void xtreemfs_replica_addRequest::SharedCtor() {
_cached_size_ = 0;
- file_id_ = const_cast< ::std::string*>(&_default_file_id_);
- path_ = const_cast< ::std::string*>(&_default_path_);
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
+ 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_));
}
@@ -14871,13 +14890,13 @@ xtreemfs_replica_addRequest::~xtreemfs_replica_addRequest() {
}
void xtreemfs_replica_addRequest::SharedDtor() {
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
if (this != default_instance_) {
@@ -14896,7 +14915,8 @@ const ::google::protobuf::Descriptor* 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_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
xtreemfs_replica_addRequest* xtreemfs_replica_addRequest::default_instance_ = NULL;
@@ -14907,22 +14927,22 @@ xtreemfs_replica_addRequest* xtreemfs_replica_addRequest::New() const {
void xtreemfs_replica_addRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
- if (_has_bit(2)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(3)) {
+ if (has_new_replica()) {
if (new_replica_ != NULL) new_replica_->::xtreemfs::pbrpc::Replica::Clear();
}
}
@@ -14951,7 +14971,7 @@ bool xtreemfs_replica_addRequest::MergePartialFromCodedStream(
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) ==
@@ -14965,7 +14985,7 @@ bool xtreemfs_replica_addRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_path;
break;
}
-
+
// optional string path = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -14982,7 +15002,7 @@ bool xtreemfs_replica_addRequest::MergePartialFromCodedStream(
if (input->ExpectTag(34)) goto parse_volume_name;
break;
}
-
+
// optional string volume_name = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -14999,7 +15019,7 @@ bool xtreemfs_replica_addRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -15019,38 +15039,38 @@ bool xtreemfs_replica_addRequest::MergePartialFromCodedStream(
void xtreemfs_replica_addRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional string file_id = 1;
- if (_has_bit(0)) {
+ 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_bit(3)) {
+ if (has_new_replica()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->new_replica(), output);
}
-
+
// optional string path = 3;
- if (_has_bit(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(
3, this->path(), output);
}
-
+
// optional string volume_name = 4;
- if (_has_bit(2)) {
+ 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);
@@ -15060,7 +15080,7 @@ void xtreemfs_replica_addRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_replica_addRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional string file_id = 1;
- if (_has_bit(0)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15068,16 +15088,16 @@ void xtreemfs_replica_addRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->file_id(), target);
}
-
+
// required .xtreemfs.pbrpc.Replica new_replica = 2;
- if (_has_bit(3)) {
+ if (has_new_replica()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
2, this->new_replica(), target);
}
-
+
// optional string path = 3;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15085,9 +15105,9 @@ void xtreemfs_replica_addRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->path(), target);
}
-
+
// optional string volume_name = 4;
- if (_has_bit(2)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15095,7 +15115,7 @@ void xtreemfs_replica_addRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->volume_name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -15105,7 +15125,7 @@ void xtreemfs_replica_addRequest::SerializeWithCachedSizes(
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()) {
@@ -15113,28 +15133,28 @@ int xtreemfs_replica_addRequest::ByteSize() const {
::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 +=
@@ -15162,16 +15182,16 @@ void xtreemfs_replica_addRequest::MergeFrom(const ::google::protobuf::Message& f
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_bit(0)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(3)) {
+ if (from.has_new_replica()) {
mutable_new_replica()->::xtreemfs::pbrpc::Replica::MergeFrom(from.new_replica());
}
}
@@ -15192,7 +15212,7 @@ void xtreemfs_replica_addRequest::CopyFrom(const xtreemfs_replica_addRequest& fr
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;
}
@@ -15222,9 +15242,6 @@ void xtreemfs_replica_addRequest::Swap(xtreemfs_replica_addRequest* other) {
// ===================================================================
-const ::std::string xtreemfs_replica_listRequest::_default_file_id_;
-const ::std::string xtreemfs_replica_listRequest::_default_path_;
-const ::std::string xtreemfs_replica_listRequest::_default_volume_name_;
#ifndef _MSC_VER
const int xtreemfs_replica_listRequest::kFileIdFieldNumber;
const int xtreemfs_replica_listRequest::kPathFieldNumber;
@@ -15247,9 +15264,9 @@ xtreemfs_replica_listRequest::xtreemfs_replica_listRequest(const xtreemfs_replic
void xtreemfs_replica_listRequest::SharedCtor() {
_cached_size_ = 0;
- file_id_ = const_cast< ::std::string*>(&_default_file_id_);
- path_ = const_cast< ::std::string*>(&_default_path_);
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
+ 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_));
}
@@ -15258,13 +15275,13 @@ xtreemfs_replica_listRequest::~xtreemfs_replica_listRequest() {
}
void xtreemfs_replica_listRequest::SharedDtor() {
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
if (this != default_instance_) {
@@ -15282,7 +15299,8 @@ const ::google::protobuf::Descriptor* 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_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
xtreemfs_replica_listRequest* xtreemfs_replica_listRequest::default_instance_ = NULL;
@@ -15293,18 +15311,18 @@ xtreemfs_replica_listRequest* xtreemfs_replica_listRequest::New() const {
void xtreemfs_replica_listRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
- if (_has_bit(2)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
@@ -15334,7 +15352,7 @@ bool xtreemfs_replica_listRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_path;
break;
}
-
+
// optional string path = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -15351,7 +15369,7 @@ bool xtreemfs_replica_listRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_volume_name;
break;
}
-
+
// optional string volume_name = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -15368,7 +15386,7 @@ bool xtreemfs_replica_listRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -15388,32 +15406,32 @@ bool xtreemfs_replica_listRequest::MergePartialFromCodedStream(
void xtreemfs_replica_listRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional string file_id = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->path(), output);
}
-
+
// optional string volume_name = 3;
- if (_has_bit(2)) {
+ 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);
@@ -15423,7 +15441,7 @@ void xtreemfs_replica_listRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_replica_listRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional string file_id = 1;
- if (_has_bit(0)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15431,9 +15449,9 @@ void xtreemfs_replica_listRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->file_id(), target);
}
-
+
// optional string path = 2;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15441,9 +15459,9 @@ void xtreemfs_replica_listRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->path(), target);
}
-
+
// optional string volume_name = 3;
- if (_has_bit(2)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15451,7 +15469,7 @@ void xtreemfs_replica_listRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->volume_name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -15461,7 +15479,7 @@ void xtreemfs_replica_listRequest::SerializeWithCachedSizes(
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()) {
@@ -15469,21 +15487,21 @@ int xtreemfs_replica_listRequest::ByteSize() const {
::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 +=
@@ -15511,13 +15529,13 @@ void xtreemfs_replica_listRequest::MergeFrom(const ::google::protobuf::Message&
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_bit(0)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
}
@@ -15537,7 +15555,7 @@ void xtreemfs_replica_listRequest::CopyFrom(const xtreemfs_replica_listRequest&
}
bool xtreemfs_replica_listRequest::IsInitialized() const {
-
+
return true;
}
@@ -15563,10 +15581,6 @@ void xtreemfs_replica_listRequest::Swap(xtreemfs_replica_listRequest* other) {
// ===================================================================
-const ::std::string xtreemfs_replica_removeRequest::_default_file_id_;
-const ::std::string xtreemfs_replica_removeRequest::_default_path_;
-const ::std::string xtreemfs_replica_removeRequest::_default_volume_name_;
-const ::std::string xtreemfs_replica_removeRequest::_default_osd_uuid_;
#ifndef _MSC_VER
const int xtreemfs_replica_removeRequest::kFileIdFieldNumber;
const int xtreemfs_replica_removeRequest::kPathFieldNumber;
@@ -15590,10 +15604,10 @@ xtreemfs_replica_removeRequest::xtreemfs_replica_removeRequest(const xtreemfs_re
void xtreemfs_replica_removeRequest::SharedCtor() {
_cached_size_ = 0;
- file_id_ = const_cast< ::std::string*>(&_default_file_id_);
- path_ = const_cast< ::std::string*>(&_default_path_);
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
- osd_uuid_ = const_cast< ::std::string*>(&_default_osd_uuid_);
+ 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_));
}
@@ -15602,16 +15616,16 @@ xtreemfs_replica_removeRequest::~xtreemfs_replica_removeRequest() {
}
void xtreemfs_replica_removeRequest::SharedDtor() {
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
- if (path_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
delete path_;
}
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
- if (osd_uuid_ != &_default_osd_uuid_) {
+ if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) {
delete osd_uuid_;
}
if (this != default_instance_) {
@@ -15629,7 +15643,8 @@ const ::google::protobuf::Descriptor* 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_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
xtreemfs_replica_removeRequest* xtreemfs_replica_removeRequest::default_instance_ = NULL;
@@ -15640,23 +15655,23 @@ xtreemfs_replica_removeRequest* xtreemfs_replica_removeRequest::New() const {
void xtreemfs_replica_removeRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
- if (_has_bit(1)) {
- if (path_ != &_default_path_) {
+ if (has_path()) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
}
- if (_has_bit(2)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
- if (_has_bit(3)) {
- if (osd_uuid_ != &_default_osd_uuid_) {
+ if (has_osd_uuid()) {
+ if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) {
osd_uuid_->clear();
}
}
@@ -15686,7 +15701,7 @@ bool xtreemfs_replica_removeRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_osd_uuid;
break;
}
-
+
// required string osd_uuid = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -15703,7 +15718,7 @@ bool xtreemfs_replica_removeRequest::MergePartialFromCodedStream(
if (input->ExpectTag(26)) goto parse_path;
break;
}
-
+
// optional string path = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -15720,7 +15735,7 @@ bool xtreemfs_replica_removeRequest::MergePartialFromCodedStream(
if (input->ExpectTag(34)) goto parse_volume_name;
break;
}
-
+
// optional string volume_name = 4;
case 4: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -15737,7 +15752,7 @@ bool xtreemfs_replica_removeRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -15757,41 +15772,41 @@ bool xtreemfs_replica_removeRequest::MergePartialFromCodedStream(
void xtreemfs_replica_removeRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional string file_id = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->osd_uuid(), output);
}
-
+
// optional string path = 3;
- if (_has_bit(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(
3, this->path(), output);
}
-
+
// optional string volume_name = 4;
- if (_has_bit(2)) {
+ 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);
@@ -15801,7 +15816,7 @@ void xtreemfs_replica_removeRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_replica_removeRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// optional string file_id = 1;
- if (_has_bit(0)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15809,9 +15824,9 @@ void xtreemfs_replica_removeRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->file_id(), target);
}
-
+
// required string osd_uuid = 2;
- if (_has_bit(3)) {
+ if (has_osd_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->osd_uuid().data(), this->osd_uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15819,9 +15834,9 @@ void xtreemfs_replica_removeRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->osd_uuid(), target);
}
-
+
// optional string path = 3;
- if (_has_bit(1)) {
+ if (has_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->path().data(), this->path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15829,9 +15844,9 @@ void xtreemfs_replica_removeRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3, this->path(), target);
}
-
+
// optional string volume_name = 4;
- if (_has_bit(2)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -15839,7 +15854,7 @@ void xtreemfs_replica_removeRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->volume_name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -15849,7 +15864,7 @@ void xtreemfs_replica_removeRequest::SerializeWithCachedSizes(
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()) {
@@ -15857,28 +15872,28 @@ int xtreemfs_replica_removeRequest::ByteSize() const {
::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 +=
@@ -15906,16 +15921,16 @@ void xtreemfs_replica_removeRequest::MergeFrom(const ::google::protobuf::Message
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_bit(0)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
- if (from._has_bit(1)) {
+ if (from.has_path()) {
set_path(from.path());
}
- if (from._has_bit(2)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
- if (from._has_bit(3)) {
+ if (from.has_osd_uuid()) {
set_osd_uuid(from.osd_uuid());
}
}
@@ -15936,7 +15951,7 @@ void xtreemfs_replica_removeRequest::CopyFrom(const xtreemfs_replica_removeReque
bool xtreemfs_replica_removeRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false;
-
+
return true;
}
@@ -15963,9 +15978,6 @@ void xtreemfs_replica_removeRequest::Swap(xtreemfs_replica_removeRequest* other)
// ===================================================================
-const ::std::string xtreemfs_restore_fileRequest::_default_file_path_;
-const ::std::string xtreemfs_restore_fileRequest::_default_file_id_;
-const ::std::string xtreemfs_restore_fileRequest::_default_osd_uuid_;
#ifndef _MSC_VER
const int xtreemfs_restore_fileRequest::kFilePathFieldNumber;
const int xtreemfs_restore_fileRequest::kFileIdFieldNumber;
@@ -15990,10 +16002,10 @@ xtreemfs_restore_fileRequest::xtreemfs_restore_fileRequest(const xtreemfs_restor
void xtreemfs_restore_fileRequest::SharedCtor() {
_cached_size_ = 0;
- file_path_ = const_cast< ::std::string*>(&_default_file_path_);
- file_id_ = const_cast< ::std::string*>(&_default_file_id_);
+ 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*>(&_default_osd_uuid_);
+ osd_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
stripe_size_ = 0u;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -16003,13 +16015,13 @@ xtreemfs_restore_fileRequest::~xtreemfs_restore_fileRequest() {
}
void xtreemfs_restore_fileRequest::SharedDtor() {
- if (file_path_ != &_default_file_path_) {
+ if (file_path_ != &::google::protobuf::internal::kEmptyString) {
delete file_path_;
}
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
- if (osd_uuid_ != &_default_osd_uuid_) {
+ if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) {
delete osd_uuid_;
}
if (this != default_instance_) {
@@ -16027,7 +16039,8 @@ const ::google::protobuf::Descriptor* 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_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
xtreemfs_restore_fileRequest* xtreemfs_restore_fileRequest::default_instance_ = NULL;
@@ -16038,19 +16051,19 @@ xtreemfs_restore_fileRequest* xtreemfs_restore_fileRequest::New() const {
void xtreemfs_restore_fileRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (file_path_ != &_default_file_path_) {
+ if (has_file_path()) {
+ if (file_path_ != &::google::protobuf::internal::kEmptyString) {
file_path_->clear();
}
}
- if (_has_bit(1)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
file_size_ = GOOGLE_ULONGLONG(0);
- if (_has_bit(3)) {
- if (osd_uuid_ != &_default_osd_uuid_) {
+ if (has_osd_uuid()) {
+ if (osd_uuid_ != &::google::protobuf::internal::kEmptyString) {
osd_uuid_->clear();
}
}
@@ -16081,7 +16094,7 @@ bool xtreemfs_restore_fileRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_file_id;
break;
}
-
+
// required string file_id = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -16098,7 +16111,7 @@ bool xtreemfs_restore_fileRequest::MergePartialFromCodedStream(
if (input->ExpectTag(25)) goto parse_file_size;
break;
}
-
+
// required fixed64 file_size = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -16107,14 +16120,14 @@ bool xtreemfs_restore_fileRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
input, &file_size_)));
- _set_bit(2);
+ 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) ==
@@ -16131,7 +16144,7 @@ bool xtreemfs_restore_fileRequest::MergePartialFromCodedStream(
if (input->ExpectTag(45)) goto parse_stripe_size;
break;
}
-
+
// required fixed32 stripe_size = 5;
case 5: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -16140,14 +16153,14 @@ bool xtreemfs_restore_fileRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
input, &stripe_size_)));
- _set_bit(4);
+ set_has_stripe_size();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -16167,42 +16180,42 @@ bool xtreemfs_restore_fileRequest::MergePartialFromCodedStream(
void xtreemfs_restore_fileRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string file_path = 1;
- if (_has_bit(0)) {
+ 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_bit(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(
2, this->file_id(), output);
}
-
+
// required fixed64 file_size = 3;
- if (_has_bit(2)) {
+ if (has_file_size()) {
::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->file_size(), output);
}
-
+
// required string osd_uuid = 4;
- if (_has_bit(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(
4, this->osd_uuid(), output);
}
-
+
// required fixed32 stripe_size = 5;
- if (_has_bit(4)) {
+ 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);
@@ -16212,7 +16225,7 @@ void xtreemfs_restore_fileRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_restore_fileRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string file_path = 1;
- if (_has_bit(0)) {
+ if (has_file_path()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_path().data(), this->file_path().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -16220,9 +16233,9 @@ void xtreemfs_restore_fileRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->file_path(), target);
}
-
+
// required string file_id = 2;
- if (_has_bit(1)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -16230,14 +16243,14 @@ void xtreemfs_restore_fileRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->file_id(), target);
}
-
+
// required fixed64 file_size = 3;
- if (_has_bit(2)) {
+ if (has_file_size()) {
target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->file_size(), target);
}
-
+
// required string osd_uuid = 4;
- if (_has_bit(3)) {
+ if (has_osd_uuid()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->osd_uuid().data(), this->osd_uuid().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -16245,12 +16258,12 @@ void xtreemfs_restore_fileRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4, this->osd_uuid(), target);
}
-
+
// required fixed32 stripe_size = 5;
- if (_has_bit(4)) {
+ 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);
@@ -16260,7 +16273,7 @@ void xtreemfs_restore_fileRequest::SerializeWithCachedSizes(
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()) {
@@ -16268,31 +16281,31 @@ int xtreemfs_restore_fileRequest::ByteSize() const {
::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 +=
@@ -16320,19 +16333,19 @@ void xtreemfs_restore_fileRequest::MergeFrom(const ::google::protobuf::Message&
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_bit(0)) {
+ if (from.has_file_path()) {
set_file_path(from.file_path());
}
- if (from._has_bit(1)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
- if (from._has_bit(2)) {
+ if (from.has_file_size()) {
set_file_size(from.file_size());
}
- if (from._has_bit(3)) {
+ if (from.has_osd_uuid()) {
set_osd_uuid(from.osd_uuid());
}
- if (from._has_bit(4)) {
+ if (from.has_stripe_size()) {
set_stripe_size(from.stripe_size());
}
}
@@ -16353,7 +16366,7 @@ void xtreemfs_restore_fileRequest::CopyFrom(const xtreemfs_restore_fileRequest&
bool xtreemfs_restore_fileRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;
-
+
return true;
}
@@ -16381,7 +16394,6 @@ void xtreemfs_restore_fileRequest::Swap(xtreemfs_restore_fileRequest* other) {
// ===================================================================
-const ::std::string xtreemfs_rmvolRequest::_default_volume_name_;
#ifndef _MSC_VER
const int xtreemfs_rmvolRequest::kVolumeNameFieldNumber;
#endif // !_MSC_VER
@@ -16402,7 +16414,7 @@ xtreemfs_rmvolRequest::xtreemfs_rmvolRequest(const xtreemfs_rmvolRequest& from)
void xtreemfs_rmvolRequest::SharedCtor() {
_cached_size_ = 0;
- volume_name_ = const_cast< ::std::string*>(&_default_volume_name_);
+ volume_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -16411,7 +16423,7 @@ xtreemfs_rmvolRequest::~xtreemfs_rmvolRequest() {
}
void xtreemfs_rmvolRequest::SharedDtor() {
- if (volume_name_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
delete volume_name_;
}
if (this != default_instance_) {
@@ -16429,7 +16441,8 @@ const ::google::protobuf::Descriptor* xtreemfs_rmvolRequest::descriptor() {
}
const xtreemfs_rmvolRequest& xtreemfs_rmvolRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *default_instance_;
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
+ return *default_instance_;
}
xtreemfs_rmvolRequest* xtreemfs_rmvolRequest::default_instance_ = NULL;
@@ -16440,8 +16453,8 @@ xtreemfs_rmvolRequest* xtreemfs_rmvolRequest::New() const {
void xtreemfs_rmvolRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (volume_name_ != &_default_volume_name_) {
+ if (has_volume_name()) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
}
@@ -16471,7 +16484,7 @@ bool xtreemfs_rmvolRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -16491,14 +16504,14 @@ bool xtreemfs_rmvolRequest::MergePartialFromCodedStream(
void xtreemfs_rmvolRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ 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);
@@ -16508,7 +16521,7 @@ void xtreemfs_rmvolRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_rmvolRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string volume_name = 1;
- if (_has_bit(0)) {
+ if (has_volume_name()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->volume_name().data(), this->volume_name().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -16516,7 +16529,7 @@ void xtreemfs_rmvolRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->volume_name(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -16526,7 +16539,7 @@ void xtreemfs_rmvolRequest::SerializeWithCachedSizes(
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()) {
@@ -16534,7 +16547,7 @@ int xtreemfs_rmvolRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->volume_name());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -16562,7 +16575,7 @@ void xtreemfs_rmvolRequest::MergeFrom(const ::google::protobuf::Message& from) {
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_bit(0)) {
+ if (from.has_volume_name()) {
set_volume_name(from.volume_name());
}
}
@@ -16583,7 +16596,7 @@ void xtreemfs_rmvolRequest::CopyFrom(const xtreemfs_rmvolRequest& from) {
bool xtreemfs_rmvolRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -16663,7 +16676,8 @@ const ::google::protobuf::Descriptor* xtreemfs_update_file_sizeRequest::descript
}
const xtreemfs_update_file_sizeRequest& xtreemfs_update_file_sizeRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *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;
@@ -16674,14 +16688,14 @@ xtreemfs_update_file_sizeRequest* xtreemfs_update_file_sizeRequest::New() const
void xtreemfs_update_file_sizeRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
+ if (has_xcap()) {
if (xcap_ != NULL) xcap_->::xtreemfs::pbrpc::XCap::Clear();
}
- if (_has_bit(1)) {
+ if (has_osd_write_response()) {
if (osd_write_response_ != NULL) osd_write_response_->::xtreemfs::pbrpc::OSDWriteResponse::Clear();
}
close_file_ = false;
- if (_has_bit(3)) {
+ if (has_coordinates()) {
if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear();
}
}
@@ -16707,7 +16721,7 @@ bool xtreemfs_update_file_sizeRequest::MergePartialFromCodedStream(
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) ==
@@ -16721,7 +16735,7 @@ bool xtreemfs_update_file_sizeRequest::MergePartialFromCodedStream(
if (input->ExpectTag(24)) goto parse_close_file;
break;
}
-
+
// optional bool close_file = 3;
case 3: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -16730,14 +16744,14 @@ bool xtreemfs_update_file_sizeRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &close_file_)));
- _set_bit(2);
+ 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) ==
@@ -16751,7 +16765,7 @@ bool xtreemfs_update_file_sizeRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -16771,28 +16785,28 @@ bool xtreemfs_update_file_sizeRequest::MergePartialFromCodedStream(
void xtreemfs_update_file_sizeRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required .xtreemfs.pbrpc.XCap xcap = 1;
- if (_has_bit(0)) {
+ if (has_xcap()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1, this->xcap(), output);
}
-
+
// required .xtreemfs.pbrpc.OSDWriteResponse osd_write_response = 2;
- if (_has_bit(1)) {
+ if (has_osd_write_response()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2, this->osd_write_response(), output);
}
-
+
// optional bool close_file = 3;
- if (_has_bit(2)) {
+ if (has_close_file()) {
::google::protobuf::internal::WireFormatLite::WriteBool(3, this->close_file(), output);
}
-
+
// optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 4;
- if (_has_bit(3)) {
+ if (has_coordinates()) {
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4, this->coordinates(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -16802,31 +16816,31 @@ void xtreemfs_update_file_sizeRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_update_file_sizeRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required .xtreemfs.pbrpc.XCap xcap = 1;
- if (_has_bit(0)) {
+ if (has_xcap()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
1, this->xcap(), target);
}
-
+
// required .xtreemfs.pbrpc.OSDWriteResponse osd_write_response = 2;
- if (_has_bit(1)) {
+ if (has_osd_write_response()) {
target = ::google::protobuf::internal::WireFormatLite::
WriteMessageNoVirtualToArray(
2, this->osd_write_response(), target);
}
-
+
// optional bool close_file = 3;
- if (_has_bit(2)) {
+ if (has_close_file()) {
target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->close_file(), target);
}
-
+
// optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 4;
- if (_has_bit(3)) {
+ 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);
@@ -16836,7 +16850,7 @@ void xtreemfs_update_file_sizeRequest::SerializeWithCachedSizes(
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()) {
@@ -16844,26 +16858,26 @@ int xtreemfs_update_file_sizeRequest::ByteSize() const {
::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 +=
@@ -16891,16 +16905,16 @@ void xtreemfs_update_file_sizeRequest::MergeFrom(const ::google::protobuf::Messa
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_bit(0)) {
+ if (from.has_xcap()) {
mutable_xcap()->::xtreemfs::pbrpc::XCap::MergeFrom(from.xcap());
}
- if (from._has_bit(1)) {
+ if (from.has_osd_write_response()) {
mutable_osd_write_response()->::xtreemfs::pbrpc::OSDWriteResponse::MergeFrom(from.osd_write_response());
}
- if (from._has_bit(2)) {
+ if (from.has_close_file()) {
set_close_file(from.close_file());
}
- if (from._has_bit(3)) {
+ if (from.has_coordinates()) {
mutable_coordinates()->::xtreemfs::pbrpc::VivaldiCoordinates::MergeFrom(from.coordinates());
}
}
@@ -16921,7 +16935,7 @@ void xtreemfs_update_file_sizeRequest::CopyFrom(const xtreemfs_update_file_sizeR
bool xtreemfs_update_file_sizeRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
if (has_xcap()) {
if (!this->xcap().IsInitialized()) return false;
}
@@ -16954,8 +16968,6 @@ void xtreemfs_update_file_sizeRequest::Swap(xtreemfs_update_file_sizeRequest* ot
// ===================================================================
-const ::std::string xtreemfs_set_replica_update_policyRequest::_default_file_id_;
-const ::std::string xtreemfs_set_replica_update_policyRequest::_default_update_policy_;
#ifndef _MSC_VER
const int xtreemfs_set_replica_update_policyRequest::kFileIdFieldNumber;
const int xtreemfs_set_replica_update_policyRequest::kUpdatePolicyFieldNumber;
@@ -16977,8 +16989,8 @@ xtreemfs_set_replica_update_policyRequest::xtreemfs_set_replica_update_policyReq
void xtreemfs_set_replica_update_policyRequest::SharedCtor() {
_cached_size_ = 0;
- file_id_ = const_cast< ::std::string*>(&_default_file_id_);
- update_policy_ = const_cast< ::std::string*>(&_default_update_policy_);
+ 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_));
}
@@ -16987,10 +16999,10 @@ xtreemfs_set_replica_update_policyRequest::~xtreemfs_set_replica_update_policyRe
}
void xtreemfs_set_replica_update_policyRequest::SharedDtor() {
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
- if (update_policy_ != &_default_update_policy_) {
+ if (update_policy_ != &::google::protobuf::internal::kEmptyString) {
delete update_policy_;
}
if (this != default_instance_) {
@@ -17008,7 +17020,8 @@ const ::google::protobuf::Descriptor* xtreemfs_set_replica_update_policyRequest:
}
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_;
+ 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;
@@ -17019,13 +17032,13 @@ xtreemfs_set_replica_update_policyRequest* xtreemfs_set_replica_update_policyReq
void xtreemfs_set_replica_update_policyRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
- if (_has_bit(1)) {
- if (update_policy_ != &_default_update_policy_) {
+ if (has_update_policy()) {
+ if (update_policy_ != &::google::protobuf::internal::kEmptyString) {
update_policy_->clear();
}
}
@@ -17055,7 +17068,7 @@ bool xtreemfs_set_replica_update_policyRequest::MergePartialFromCodedStream(
if (input->ExpectTag(18)) goto parse_update_policy;
break;
}
-
+
// required string update_policy = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -17072,7 +17085,7 @@ bool xtreemfs_set_replica_update_policyRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -17092,23 +17105,23 @@ bool xtreemfs_set_replica_update_policyRequest::MergePartialFromCodedStream(
void xtreemfs_set_replica_update_policyRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string file_id = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ 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);
@@ -17118,7 +17131,7 @@ void xtreemfs_set_replica_update_policyRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_set_replica_update_policyRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string file_id = 1;
- if (_has_bit(0)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -17126,9 +17139,9 @@ void xtreemfs_set_replica_update_policyRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->file_id(), target);
}
-
+
// required string update_policy = 2;
- if (_has_bit(1)) {
+ if (has_update_policy()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->update_policy().data(), this->update_policy().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -17136,7 +17149,7 @@ void xtreemfs_set_replica_update_policyRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->update_policy(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -17146,7 +17159,7 @@ void xtreemfs_set_replica_update_policyRequest::SerializeWithCachedSizes(
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()) {
@@ -17154,14 +17167,14 @@ int xtreemfs_set_replica_update_policyRequest::ByteSize() const {
::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 +=
@@ -17189,10 +17202,10 @@ void xtreemfs_set_replica_update_policyRequest::MergeFrom(const ::google::protob
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_bit(0)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
- if (from._has_bit(1)) {
+ if (from.has_update_policy()) {
set_update_policy(from.update_policy());
}
}
@@ -17213,7 +17226,7 @@ void xtreemfs_set_replica_update_policyRequest::CopyFrom(const xtreemfs_set_repl
bool xtreemfs_set_replica_update_policyRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
@@ -17238,7 +17251,6 @@ void xtreemfs_set_replica_update_policyRequest::Swap(xtreemfs_set_replica_update
// ===================================================================
-const ::std::string xtreemfs_set_replica_update_policyResponse::_default_old_update_policy_;
#ifndef _MSC_VER
const int xtreemfs_set_replica_update_policyResponse::kOldUpdatePolicyFieldNumber;
#endif // !_MSC_VER
@@ -17259,7 +17271,7 @@ xtreemfs_set_replica_update_policyResponse::xtreemfs_set_replica_update_policyRe
void xtreemfs_set_replica_update_policyResponse::SharedCtor() {
_cached_size_ = 0;
- old_update_policy_ = const_cast< ::std::string*>(&_default_old_update_policy_);
+ old_update_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -17268,7 +17280,7 @@ xtreemfs_set_replica_update_policyResponse::~xtreemfs_set_replica_update_policyR
}
void xtreemfs_set_replica_update_policyResponse::SharedDtor() {
- if (old_update_policy_ != &_default_old_update_policy_) {
+ if (old_update_policy_ != &::google::protobuf::internal::kEmptyString) {
delete old_update_policy_;
}
if (this != default_instance_) {
@@ -17286,7 +17298,8 @@ const ::google::protobuf::Descriptor* xtreemfs_set_replica_update_policyResponse
}
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_;
+ 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;
@@ -17297,8 +17310,8 @@ xtreemfs_set_replica_update_policyResponse* xtreemfs_set_replica_update_policyRe
void xtreemfs_set_replica_update_policyResponse::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (old_update_policy_ != &_default_old_update_policy_) {
+ if (has_old_update_policy()) {
+ if (old_update_policy_ != &::google::protobuf::internal::kEmptyString) {
old_update_policy_->clear();
}
}
@@ -17328,7 +17341,7 @@ bool xtreemfs_set_replica_update_policyResponse::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -17348,14 +17361,14 @@ bool xtreemfs_set_replica_update_policyResponse::MergePartialFromCodedStream(
void xtreemfs_set_replica_update_policyResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string old_update_policy = 1;
- if (_has_bit(0)) {
+ 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);
@@ -17365,7 +17378,7 @@ void xtreemfs_set_replica_update_policyResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_set_replica_update_policyResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string old_update_policy = 1;
- if (_has_bit(0)) {
+ 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);
@@ -17373,7 +17386,7 @@ void xtreemfs_set_replica_update_policyResponse::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->old_update_policy(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -17383,7 +17396,7 @@ void xtreemfs_set_replica_update_policyResponse::SerializeWithCachedSizes(
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()) {
@@ -17391,7 +17404,7 @@ int xtreemfs_set_replica_update_policyResponse::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->old_update_policy());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -17419,7 +17432,7 @@ void xtreemfs_set_replica_update_policyResponse::MergeFrom(const ::google::proto
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_bit(0)) {
+ if (from.has_old_update_policy()) {
set_old_update_policy(from.old_update_policy());
}
}
@@ -17440,7 +17453,7 @@ void xtreemfs_set_replica_update_policyResponse::CopyFrom(const xtreemfs_set_rep
bool xtreemfs_set_replica_update_policyResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -17464,7 +17477,6 @@ void xtreemfs_set_replica_update_policyResponse::Swap(xtreemfs_set_replica_updat
// ===================================================================
-const ::std::string xtreemfs_set_read_only_xattrRequest::_default_file_id_;
#ifndef _MSC_VER
const int xtreemfs_set_read_only_xattrRequest::kFileIdFieldNumber;
const int xtreemfs_set_read_only_xattrRequest::kValueFieldNumber;
@@ -17486,7 +17498,7 @@ xtreemfs_set_read_only_xattrRequest::xtreemfs_set_read_only_xattrRequest(const x
void xtreemfs_set_read_only_xattrRequest::SharedCtor() {
_cached_size_ = 0;
- file_id_ = const_cast< ::std::string*>(&_default_file_id_);
+ file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
value_ = false;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -17496,7 +17508,7 @@ xtreemfs_set_read_only_xattrRequest::~xtreemfs_set_read_only_xattrRequest() {
}
void xtreemfs_set_read_only_xattrRequest::SharedDtor() {
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
if (this != default_instance_) {
@@ -17514,7 +17526,8 @@ const ::google::protobuf::Descriptor* xtreemfs_set_read_only_xattrRequest::descr
}
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_;
+ 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;
@@ -17525,8 +17538,8 @@ xtreemfs_set_read_only_xattrRequest* xtreemfs_set_read_only_xattrRequest::New()
void xtreemfs_set_read_only_xattrRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
@@ -17557,7 +17570,7 @@ bool xtreemfs_set_read_only_xattrRequest::MergePartialFromCodedStream(
if (input->ExpectTag(16)) goto parse_value;
break;
}
-
+
// required bool value = 2;
case 2: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -17566,14 +17579,14 @@ bool xtreemfs_set_read_only_xattrRequest::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &value_)));
- _set_bit(1);
+ set_has_value();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -17593,19 +17606,19 @@ bool xtreemfs_set_read_only_xattrRequest::MergePartialFromCodedStream(
void xtreemfs_set_read_only_xattrRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string file_id = 1;
- if (_has_bit(0)) {
+ 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_bit(1)) {
+ if (has_value()) {
::google::protobuf::internal::WireFormatLite::WriteBool(2, this->value(), output);
}
-
+
if (!unknown_fields().empty()) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
unknown_fields(), output);
@@ -17615,7 +17628,7 @@ void xtreemfs_set_read_only_xattrRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_set_read_only_xattrRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string file_id = 1;
- if (_has_bit(0)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -17623,12 +17636,12 @@ void xtreemfs_set_read_only_xattrRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->file_id(), target);
}
-
+
// required bool value = 2;
- if (_has_bit(1)) {
+ 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);
@@ -17638,7 +17651,7 @@ void xtreemfs_set_read_only_xattrRequest::SerializeWithCachedSizes(
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()) {
@@ -17646,12 +17659,12 @@ int xtreemfs_set_read_only_xattrRequest::ByteSize() const {
::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 +=
@@ -17679,10 +17692,10 @@ void xtreemfs_set_read_only_xattrRequest::MergeFrom(const ::google::protobuf::Me
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_bit(0)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
- if (from._has_bit(1)) {
+ if (from.has_value()) {
set_value(from.value());
}
}
@@ -17703,7 +17716,7 @@ void xtreemfs_set_read_only_xattrRequest::CopyFrom(const xtreemfs_set_read_only_
bool xtreemfs_set_read_only_xattrRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+
return true;
}
@@ -17772,7 +17785,8 @@ const ::google::protobuf::Descriptor* xtreemfs_set_read_only_xattrResponse::desc
}
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_;
+ 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;
@@ -17802,14 +17816,14 @@ bool xtreemfs_set_read_only_xattrResponse::MergePartialFromCodedStream(
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
input, &was_set_)));
- _set_bit(0);
+ set_has_was_set();
} else {
goto handle_uninterpreted;
}
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -17829,10 +17843,10 @@ bool xtreemfs_set_read_only_xattrResponse::MergePartialFromCodedStream(
void xtreemfs_set_read_only_xattrResponse::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required bool was_set = 1;
- if (_has_bit(0)) {
+ 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);
@@ -17842,10 +17856,10 @@ void xtreemfs_set_read_only_xattrResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_set_read_only_xattrResponse::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required bool was_set = 1;
- if (_has_bit(0)) {
+ 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);
@@ -17855,13 +17869,13 @@ void xtreemfs_set_read_only_xattrResponse::SerializeWithCachedSizes(
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 +=
@@ -17889,7 +17903,7 @@ void xtreemfs_set_read_only_xattrResponse::MergeFrom(const ::google::protobuf::M
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_bit(0)) {
+ if (from.has_was_set()) {
set_was_set(from.was_set());
}
}
@@ -17910,7 +17924,7 @@ void xtreemfs_set_read_only_xattrResponse::CopyFrom(const xtreemfs_set_read_only
bool xtreemfs_set_read_only_xattrResponse::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -17934,7 +17948,6 @@ void xtreemfs_set_read_only_xattrResponse::Swap(xtreemfs_set_read_only_xattrResp
// ===================================================================
-const ::std::string xtreemfs_get_file_credentialsRequest::_default_file_id_;
#ifndef _MSC_VER
const int xtreemfs_get_file_credentialsRequest::kFileIdFieldNumber;
#endif // !_MSC_VER
@@ -17955,7 +17968,7 @@ xtreemfs_get_file_credentialsRequest::xtreemfs_get_file_credentialsRequest(const
void xtreemfs_get_file_credentialsRequest::SharedCtor() {
_cached_size_ = 0;
- file_id_ = const_cast< ::std::string*>(&_default_file_id_);
+ file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
@@ -17964,7 +17977,7 @@ xtreemfs_get_file_credentialsRequest::~xtreemfs_get_file_credentialsRequest() {
}
void xtreemfs_get_file_credentialsRequest::SharedDtor() {
- if (file_id_ != &_default_file_id_) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
delete file_id_;
}
if (this != default_instance_) {
@@ -17982,7 +17995,8 @@ const ::google::protobuf::Descriptor* xtreemfs_get_file_credentialsRequest::desc
}
const xtreemfs_get_file_credentialsRequest& xtreemfs_get_file_credentialsRequest::default_instance() {
- if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fMRC_2eproto(); return *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;
@@ -17993,8 +18007,8 @@ xtreemfs_get_file_credentialsRequest* xtreemfs_get_file_credentialsRequest::New(
void xtreemfs_get_file_credentialsRequest::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
- if (_has_bit(0)) {
- if (file_id_ != &_default_file_id_) {
+ if (has_file_id()) {
+ if (file_id_ != &::google::protobuf::internal::kEmptyString) {
file_id_->clear();
}
}
@@ -18024,7 +18038,7 @@ bool xtreemfs_get_file_credentialsRequest::MergePartialFromCodedStream(
if (input->ExpectAtEnd()) return true;
break;
}
-
+
default: {
handle_uninterpreted:
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -18044,14 +18058,14 @@ bool xtreemfs_get_file_credentialsRequest::MergePartialFromCodedStream(
void xtreemfs_get_file_credentialsRequest::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required string file_id = 1;
- if (_has_bit(0)) {
+ 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);
@@ -18061,7 +18075,7 @@ void xtreemfs_get_file_credentialsRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* xtreemfs_get_file_credentialsRequest::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required string file_id = 1;
- if (_has_bit(0)) {
+ if (has_file_id()) {
::google::protobuf::internal::WireFormat::VerifyUTF8String(
this->file_id().data(), this->file_id().length(),
::google::protobuf::internal::WireFormat::SERIALIZE);
@@ -18069,7 +18083,7 @@ void xtreemfs_get_file_credentialsRequest::SerializeWithCachedSizes(
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1, this->file_id(), target);
}
-
+
if (!unknown_fields().empty()) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
unknown_fields(), target);
@@ -18079,7 +18093,7 @@ void xtreemfs_get_file_credentialsRequest::SerializeWithCachedSizes(
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()) {
@@ -18087,7 +18101,7 @@ int xtreemfs_get_file_credentialsRequest::ByteSize() const {
::google::protobuf::internal::WireFormatLite::StringSize(
this->file_id());
}
-
+
}
if (!unknown_fields().empty()) {
total_size +=
@@ -18115,7 +18129,7 @@ void xtreemfs_get_file_credentialsRequest::MergeFrom(const ::google::protobuf::M
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_bit(0)) {
+ if (from.has_file_id()) {
set_file_id(from.file_id());
}
}
@@ -18136,7 +18150,7 @@ void xtreemfs_get_file_credentialsRequest::CopyFrom(const xtreemfs_get_file_cred
bool xtreemfs_get_file_credentialsRequest::IsInitialized() const {
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+
return true;
}
@@ -18158,1065 +18172,6 @@ void xtreemfs_get_file_credentialsRequest::Swap(xtreemfs_get_file_credentialsReq
}
-// ===================================================================
-
-MRCService::~MRCService() {}
-
-const ::google::protobuf::ServiceDescriptor* MRCService::descriptor() {
- protobuf_AssignDescriptorsOnce();
- return MRCService_descriptor_;
-}
-
-const ::google::protobuf::ServiceDescriptor* MRCService::GetDescriptor() {
- protobuf_AssignDescriptorsOnce();
- return MRCService_descriptor_;
-}
-
-void MRCService::fsetattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::fsetattrRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method fsetattr() not implemented.");
- done->Run();
-}
-
-void MRCService::ftruncate(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::XCap*,
- ::xtreemfs::pbrpc::XCap*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method ftruncate() not implemented.");
- done->Run();
-}
-
-void MRCService::getattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::getattrRequest*,
- ::xtreemfs::pbrpc::getattrResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method getattr() not implemented.");
- done->Run();
-}
-
-void MRCService::getxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::getxattrRequest*,
- ::xtreemfs::pbrpc::getxattrResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method getxattr() not implemented.");
- done->Run();
-}
-
-void MRCService::link(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::linkRequest*,
- ::xtreemfs::pbrpc::timestampResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method link() not implemented.");
- done->Run();
-}
-
-void MRCService::listxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::listxattrRequest*,
- ::xtreemfs::pbrpc::listxattrResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method listxattr() not implemented.");
- done->Run();
-}
-
-void MRCService::mkdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::mkdirRequest*,
- ::xtreemfs::pbrpc::timestampResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method mkdir() not implemented.");
- done->Run();
-}
-
-void MRCService::open(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::openRequest*,
- ::xtreemfs::pbrpc::openResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method open() not implemented.");
- done->Run();
-}
-
-void MRCService::readdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::readdirRequest*,
- ::xtreemfs::pbrpc::DirectoryEntries*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method readdir() not implemented.");
- done->Run();
-}
-
-void MRCService::readlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::readlinkRequest*,
- ::xtreemfs::pbrpc::readlinkResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method readlink() not implemented.");
- done->Run();
-}
-
-void MRCService::removexattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::removexattrRequest*,
- ::xtreemfs::pbrpc::timestampResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method removexattr() not implemented.");
- done->Run();
-}
-
-void MRCService::rename(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::renameRequest*,
- ::xtreemfs::pbrpc::renameResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method rename() not implemented.");
- done->Run();
-}
-
-void MRCService::rmdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::rmdirRequest*,
- ::xtreemfs::pbrpc::timestampResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method rmdir() not implemented.");
- done->Run();
-}
-
-void MRCService::setattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::setattrRequest*,
- ::xtreemfs::pbrpc::timestampResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method setattr() not implemented.");
- done->Run();
-}
-
-void MRCService::setxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::setxattrRequest*,
- ::xtreemfs::pbrpc::timestampResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method setxattr() not implemented.");
- done->Run();
-}
-
-void MRCService::statvfs(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::statvfsRequest*,
- ::xtreemfs::pbrpc::StatVFS*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method statvfs() not implemented.");
- done->Run();
-}
-
-void MRCService::symlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::symlinkRequest*,
- ::xtreemfs::pbrpc::timestampResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method symlink() not implemented.");
- done->Run();
-}
-
-void MRCService::unlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::unlinkRequest*,
- ::xtreemfs::pbrpc::unlinkResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method unlink() not implemented.");
- done->Run();
-}
-
-void MRCService::access(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::accessRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method access() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_checkpoint(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_checkpoint() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_check_file_exists(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_check_file_existsRequest*,
- ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_check_file_exists() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_dump_database(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_dump_database() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_get_suitable_osds(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsRequest*,
- ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_get_suitable_osds() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_internal_debug(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::stringMessage*,
- ::xtreemfs::pbrpc::stringMessage*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_internal_debug() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_listdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_listdirRequest*,
- ::xtreemfs::pbrpc::xtreemfs_listdirResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_listdir() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_lsvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest*,
- ::xtreemfs::pbrpc::Volumes*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_lsvol() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_mkvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Volume*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_mkvol() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_renew_capability(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::XCap*,
- ::xtreemfs::pbrpc::XCap*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_renew_capability() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_replication_to_master(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_replication_to_master() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_replica_add(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_addRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_replica_add() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_replica_list(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_listRequest*,
- ::xtreemfs::pbrpc::Replicas*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_replica_list() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_replica_remove(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_removeRequest*,
- ::xtreemfs::pbrpc::FileCredentials*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_replica_remove() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_restore_database(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_restore_database() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_restore_file(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_restore_fileRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_restore_file() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_rmvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_rmvolRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_rmvol() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_shutdown(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest*,
- ::xtreemfs::pbrpc::emptyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_shutdown() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_update_file_size(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_update_file_sizeRequest*,
- ::xtreemfs::pbrpc::timestampResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_update_file_size() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_set_replica_update_policy(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyRequest*,
- ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_set_replica_update_policy() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_set_read_only_xattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrRequest*,
- ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrResponse*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_set_read_only_xattr() not implemented.");
- done->Run();
-}
-
-void MRCService::xtreemfs_get_file_credentials(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_get_file_credentialsRequest*,
- ::xtreemfs::pbrpc::FileCredentials*,
- ::google::protobuf::Closure* done) {
- controller->SetFailed("Method xtreemfs_get_file_credentials() not implemented.");
- done->Run();
-}
-
-void MRCService::CallMethod(const ::google::protobuf::MethodDescriptor* method,
- ::google::protobuf::RpcController* controller,
- const ::google::protobuf::Message* request,
- ::google::protobuf::Message* response,
- ::google::protobuf::Closure* done) {
- GOOGLE_DCHECK_EQ(method->service(), MRCService_descriptor_);
- switch(method->index()) {
- case 0:
- fsetattr(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 1:
- ftruncate(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::XCap*>(response),
- done);
- break;
- case 2:
- getattr(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::getattrResponse*>(response),
- done);
- break;
- case 3:
- getxattr(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::getxattrResponse*>(response),
- done);
- break;
- case 4:
- link(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::timestampResponse*>(response),
- done);
- break;
- case 5:
- listxattr(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::listxattrResponse*>(response),
- done);
- break;
- case 6:
- mkdir(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::timestampResponse*>(response),
- done);
- break;
- case 7:
- open(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::openResponse*>(response),
- done);
- break;
- case 8:
- readdir(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::DirectoryEntries*>(response),
- done);
- break;
- case 9:
- readlink(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::readlinkResponse*>(response),
- done);
- break;
- case 10:
- removexattr(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::timestampResponse*>(response),
- done);
- break;
- case 11:
- rename(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::renameResponse*>(response),
- done);
- break;
- case 12:
- rmdir(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::timestampResponse*>(response),
- done);
- break;
- case 13:
- setattr(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::timestampResponse*>(response),
- done);
- break;
- case 14:
- setxattr(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::timestampResponse*>(response),
- done);
- break;
- case 15:
- statvfs(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::StatVFS*>(response),
- done);
- break;
- case 16:
- symlink(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::timestampResponse*>(response),
- done);
- break;
- case 17:
- unlink(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::unlinkResponse*>(response),
- done);
- break;
- case 18:
- access(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 19:
- xtreemfs_checkpoint(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 20:
- xtreemfs_check_file_exists(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse*>(response),
- done);
- break;
- case 21:
- xtreemfs_dump_database(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 22:
- xtreemfs_get_suitable_osds(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsResponse*>(response),
- done);
- break;
- case 23:
- xtreemfs_internal_debug(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::stringMessage*>(response),
- done);
- break;
- case 24:
- xtreemfs_listdir(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::xtreemfs_listdirResponse*>(response),
- done);
- break;
- case 25:
- xtreemfs_lsvol(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::Volumes*>(response),
- done);
- break;
- case 26:
- xtreemfs_mkvol(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 27:
- xtreemfs_renew_capability(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::XCap*>(response),
- done);
- break;
- case 28:
- xtreemfs_replication_to_master(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 29:
- xtreemfs_replica_add(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 30:
- xtreemfs_replica_list(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::Replicas*>(response),
- done);
- break;
- case 31:
- xtreemfs_replica_remove(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::FileCredentials*>(response),
- done);
- break;
- case 32:
- xtreemfs_restore_database(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 33:
- xtreemfs_restore_file(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 34:
- xtreemfs_rmvol(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 35:
- xtreemfs_shutdown(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::emptyResponse*>(response),
- done);
- break;
- case 36:
- xtreemfs_update_file_size(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::timestampResponse*>(response),
- done);
- break;
- case 37:
- xtreemfs_set_replica_update_policy(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyResponse*>(response),
- done);
- break;
- case 38:
- xtreemfs_set_read_only_xattr(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrResponse*>(response),
- done);
- break;
- case 39:
- xtreemfs_get_file_credentials(controller,
- ::google::protobuf::down_cast(request),
- ::google::protobuf::down_cast< ::xtreemfs::pbrpc::FileCredentials*>(response),
- done);
- break;
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- break;
- }
-}
-
-const ::google::protobuf::Message& MRCService::GetRequestPrototype(
- const ::google::protobuf::MethodDescriptor* method) const {
- GOOGLE_DCHECK_EQ(method->service(), descriptor());
- switch(method->index()) {
- case 0:
- return ::xtreemfs::pbrpc::fsetattrRequest::default_instance();
- case 1:
- return ::xtreemfs::pbrpc::XCap::default_instance();
- case 2:
- return ::xtreemfs::pbrpc::getattrRequest::default_instance();
- case 3:
- return ::xtreemfs::pbrpc::getxattrRequest::default_instance();
- case 4:
- return ::xtreemfs::pbrpc::linkRequest::default_instance();
- case 5:
- return ::xtreemfs::pbrpc::listxattrRequest::default_instance();
- case 6:
- return ::xtreemfs::pbrpc::mkdirRequest::default_instance();
- case 7:
- return ::xtreemfs::pbrpc::openRequest::default_instance();
- case 8:
- return ::xtreemfs::pbrpc::readdirRequest::default_instance();
- case 9:
- return ::xtreemfs::pbrpc::readlinkRequest::default_instance();
- case 10:
- return ::xtreemfs::pbrpc::removexattrRequest::default_instance();
- case 11:
- return ::xtreemfs::pbrpc::renameRequest::default_instance();
- case 12:
- return ::xtreemfs::pbrpc::rmdirRequest::default_instance();
- case 13:
- return ::xtreemfs::pbrpc::setattrRequest::default_instance();
- case 14:
- return ::xtreemfs::pbrpc::setxattrRequest::default_instance();
- case 15:
- return ::xtreemfs::pbrpc::statvfsRequest::default_instance();
- case 16:
- return ::xtreemfs::pbrpc::symlinkRequest::default_instance();
- case 17:
- return ::xtreemfs::pbrpc::unlinkRequest::default_instance();
- case 18:
- return ::xtreemfs::pbrpc::accessRequest::default_instance();
- case 19:
- return ::xtreemfs::pbrpc::emptyRequest::default_instance();
- case 20:
- return ::xtreemfs::pbrpc::xtreemfs_check_file_existsRequest::default_instance();
- case 21:
- return ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest::default_instance();
- case 22:
- return ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsRequest::default_instance();
- case 23:
- return ::xtreemfs::pbrpc::stringMessage::default_instance();
- case 24:
- return ::xtreemfs::pbrpc::xtreemfs_listdirRequest::default_instance();
- case 25:
- return ::xtreemfs::pbrpc::emptyRequest::default_instance();
- case 26:
- return ::xtreemfs::pbrpc::Volume::default_instance();
- case 27:
- return ::xtreemfs::pbrpc::XCap::default_instance();
- case 28:
- return ::xtreemfs::pbrpc::emptyRequest::default_instance();
- case 29:
- return ::xtreemfs::pbrpc::xtreemfs_replica_addRequest::default_instance();
- case 30:
- return ::xtreemfs::pbrpc::xtreemfs_replica_listRequest::default_instance();
- case 31:
- return ::xtreemfs::pbrpc::xtreemfs_replica_removeRequest::default_instance();
- case 32:
- return ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest::default_instance();
- case 33:
- return ::xtreemfs::pbrpc::xtreemfs_restore_fileRequest::default_instance();
- case 34:
- return ::xtreemfs::pbrpc::xtreemfs_rmvolRequest::default_instance();
- case 35:
- return ::xtreemfs::pbrpc::emptyRequest::default_instance();
- case 36:
- return ::xtreemfs::pbrpc::xtreemfs_update_file_sizeRequest::default_instance();
- case 37:
- return ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyRequest::default_instance();
- case 38:
- return ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrRequest::default_instance();
- case 39:
- return ::xtreemfs::pbrpc::xtreemfs_get_file_credentialsRequest::default_instance();
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- return *reinterpret_cast< ::google::protobuf::Message*>(NULL);
- }
-}
-
-const ::google::protobuf::Message& MRCService::GetResponsePrototype(
- const ::google::protobuf::MethodDescriptor* method) const {
- GOOGLE_DCHECK_EQ(method->service(), descriptor());
- switch(method->index()) {
- case 0:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 1:
- return ::xtreemfs::pbrpc::XCap::default_instance();
- case 2:
- return ::xtreemfs::pbrpc::getattrResponse::default_instance();
- case 3:
- return ::xtreemfs::pbrpc::getxattrResponse::default_instance();
- case 4:
- return ::xtreemfs::pbrpc::timestampResponse::default_instance();
- case 5:
- return ::xtreemfs::pbrpc::listxattrResponse::default_instance();
- case 6:
- return ::xtreemfs::pbrpc::timestampResponse::default_instance();
- case 7:
- return ::xtreemfs::pbrpc::openResponse::default_instance();
- case 8:
- return ::xtreemfs::pbrpc::DirectoryEntries::default_instance();
- case 9:
- return ::xtreemfs::pbrpc::readlinkResponse::default_instance();
- case 10:
- return ::xtreemfs::pbrpc::timestampResponse::default_instance();
- case 11:
- return ::xtreemfs::pbrpc::renameResponse::default_instance();
- case 12:
- return ::xtreemfs::pbrpc::timestampResponse::default_instance();
- case 13:
- return ::xtreemfs::pbrpc::timestampResponse::default_instance();
- case 14:
- return ::xtreemfs::pbrpc::timestampResponse::default_instance();
- case 15:
- return ::xtreemfs::pbrpc::StatVFS::default_instance();
- case 16:
- return ::xtreemfs::pbrpc::timestampResponse::default_instance();
- case 17:
- return ::xtreemfs::pbrpc::unlinkResponse::default_instance();
- case 18:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 19:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 20:
- return ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse::default_instance();
- case 21:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 22:
- return ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsResponse::default_instance();
- case 23:
- return ::xtreemfs::pbrpc::stringMessage::default_instance();
- case 24:
- return ::xtreemfs::pbrpc::xtreemfs_listdirResponse::default_instance();
- case 25:
- return ::xtreemfs::pbrpc::Volumes::default_instance();
- case 26:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 27:
- return ::xtreemfs::pbrpc::XCap::default_instance();
- case 28:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 29:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 30:
- return ::xtreemfs::pbrpc::Replicas::default_instance();
- case 31:
- return ::xtreemfs::pbrpc::FileCredentials::default_instance();
- case 32:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 33:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 34:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 35:
- return ::xtreemfs::pbrpc::emptyResponse::default_instance();
- case 36:
- return ::xtreemfs::pbrpc::timestampResponse::default_instance();
- case 37:
- return ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyResponse::default_instance();
- case 38:
- return ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrResponse::default_instance();
- case 39:
- return ::xtreemfs::pbrpc::FileCredentials::default_instance();
- default:
- GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
- return *reinterpret_cast< ::google::protobuf::Message*>(NULL);
- }
-}
-
-MRCService_Stub::MRCService_Stub(::google::protobuf::RpcChannel* channel)
- : channel_(channel), owns_channel_(false) {}
-MRCService_Stub::MRCService_Stub(
- ::google::protobuf::RpcChannel* channel,
- ::google::protobuf::Service::ChannelOwnership ownership)
- : channel_(channel),
- owns_channel_(ownership == ::google::protobuf::Service::STUB_OWNS_CHANNEL) {}
-MRCService_Stub::~MRCService_Stub() {
- if (owns_channel_) delete channel_;
-}
-
-void MRCService_Stub::fsetattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::fsetattrRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(0),
- controller, request, response, done);
-}
-void MRCService_Stub::ftruncate(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::XCap* request,
- ::xtreemfs::pbrpc::XCap* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(1),
- controller, request, response, done);
-}
-void MRCService_Stub::getattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::getattrRequest* request,
- ::xtreemfs::pbrpc::getattrResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(2),
- controller, request, response, done);
-}
-void MRCService_Stub::getxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::getxattrRequest* request,
- ::xtreemfs::pbrpc::getxattrResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(3),
- controller, request, response, done);
-}
-void MRCService_Stub::link(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::linkRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(4),
- controller, request, response, done);
-}
-void MRCService_Stub::listxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::listxattrRequest* request,
- ::xtreemfs::pbrpc::listxattrResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(5),
- controller, request, response, done);
-}
-void MRCService_Stub::mkdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::mkdirRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(6),
- controller, request, response, done);
-}
-void MRCService_Stub::open(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::openRequest* request,
- ::xtreemfs::pbrpc::openResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(7),
- controller, request, response, done);
-}
-void MRCService_Stub::readdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::readdirRequest* request,
- ::xtreemfs::pbrpc::DirectoryEntries* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(8),
- controller, request, response, done);
-}
-void MRCService_Stub::readlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::readlinkRequest* request,
- ::xtreemfs::pbrpc::readlinkResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(9),
- controller, request, response, done);
-}
-void MRCService_Stub::removexattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::removexattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(10),
- controller, request, response, done);
-}
-void MRCService_Stub::rename(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::renameRequest* request,
- ::xtreemfs::pbrpc::renameResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(11),
- controller, request, response, done);
-}
-void MRCService_Stub::rmdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::rmdirRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(12),
- controller, request, response, done);
-}
-void MRCService_Stub::setattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::setattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(13),
- controller, request, response, done);
-}
-void MRCService_Stub::setxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::setxattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(14),
- controller, request, response, done);
-}
-void MRCService_Stub::statvfs(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::statvfsRequest* request,
- ::xtreemfs::pbrpc::StatVFS* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(15),
- controller, request, response, done);
-}
-void MRCService_Stub::symlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::symlinkRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(16),
- controller, request, response, done);
-}
-void MRCService_Stub::unlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::unlinkRequest* request,
- ::xtreemfs::pbrpc::unlinkResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(17),
- controller, request, response, done);
-}
-void MRCService_Stub::access(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::accessRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(18),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_checkpoint(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(19),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_check_file_exists(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_check_file_existsRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(20),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_dump_database(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(21),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_get_suitable_osds(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(22),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_internal_debug(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::stringMessage* request,
- ::xtreemfs::pbrpc::stringMessage* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(23),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_listdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_listdirRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_listdirResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(24),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_lsvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::Volumes* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(25),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_mkvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Volume* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(26),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_renew_capability(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::XCap* request,
- ::xtreemfs::pbrpc::XCap* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(27),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_replication_to_master(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(28),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_replica_add(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_addRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(29),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_replica_list(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_listRequest* request,
- ::xtreemfs::pbrpc::Replicas* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(30),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_replica_remove(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_removeRequest* request,
- ::xtreemfs::pbrpc::FileCredentials* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(31),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_restore_database(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(32),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_restore_file(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_restore_fileRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(33),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_rmvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_rmvolRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(34),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_shutdown(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(35),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_update_file_size(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_update_file_sizeRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(36),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_set_replica_update_policy(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(37),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_set_read_only_xattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrResponse* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(38),
- controller, request, response, done);
-}
-void MRCService_Stub::xtreemfs_get_file_credentials(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_get_file_credentialsRequest* request,
- ::xtreemfs::pbrpc::FileCredentials* response,
- ::google::protobuf::Closure* done) {
- channel_->CallMethod(descriptor()->method(39),
- controller, request, response, done);
-}
-
// @@protoc_insertion_point(namespace_scope)
} // namespace pbrpc
diff --git a/cpp/generated/xtreemfs/MRC.pb.h b/cpp/generated/xtreemfs/MRC.pb.h
index 43ef6243c4b8f4e5ac7f74cc6c52d13c22f9845a..8b900941347ad70a05faae799301f709f6d2c7e3 100644
--- a/cpp/generated/xtreemfs/MRC.pb.h
+++ b/cpp/generated/xtreemfs/MRC.pb.h
@@ -8,22 +8,23 @@
#include
-#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#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
#include "include/PBRPC.pb.h"
#include "include/Common.pb.h"
#include "xtreemfs/GlobalTypes.pb.h"
@@ -161,29 +162,29 @@ 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);
@@ -191,7 +192,7 @@ class Stat : public ::google::protobuf::Message {
void MergeFrom(const Stat& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -204,41 +205,41 @@ class Stat : public ::google::protobuf::Message {
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();
@@ -248,7 +249,9 @@ class Stat : public ::google::protobuf::Message {
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();
@@ -258,101 +261,120 @@ class Stat : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::google::protobuf::uint64 dev_;
::google::protobuf::uint64 ino_;
::google::protobuf::uint32 mode_;
::google::protobuf::uint32 nlink_;
::std::string* user_id_;
- static const ::std::string _default_user_id_;
::std::string* group_id_;
- static const ::std::string _default_group_id_;
::google::protobuf::uint64 size_;
::google::protobuf::uint64 atime_ns_;
::google::protobuf::uint64 mtime_ns_;
::google::protobuf::uint64 ctime_ns_;
- ::google::protobuf::uint32 blksize_;
::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();
-
- ::google::protobuf::uint32 _has_bits_[(14 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Stat* default_instance_;
};
@@ -362,29 +384,29 @@ 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);
@@ -392,7 +414,7 @@ class DirectoryEntry : public ::google::protobuf::Message {
void MergeFrom(const DirectoryEntry& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -405,13 +427,13 @@ class DirectoryEntry : public ::google::protobuf::Message {
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();
@@ -421,39 +443,37 @@ class DirectoryEntry : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static DirectoryEntry* default_instance_;
};
@@ -463,29 +483,29 @@ 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);
@@ -493,7 +513,7 @@ class DirectoryEntries : public ::google::protobuf::Message {
void MergeFrom(const DirectoryEntries& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -506,13 +526,13 @@ class DirectoryEntries : public ::google::protobuf::Message {
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();
@@ -524,30 +544,21 @@ class DirectoryEntries : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static DirectoryEntries* default_instance_;
};
@@ -557,29 +568,29 @@ 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);
@@ -587,7 +598,7 @@ class XAttr : public ::google::protobuf::Message {
void MergeFrom(const XAttr& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -600,13 +611,13 @@ class XAttr : public ::google::protobuf::Message {
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();
@@ -616,7 +627,9 @@ class XAttr : public ::google::protobuf::Message {
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();
@@ -626,45 +639,43 @@ class XAttr : public ::google::protobuf::Message {
inline void set_value(const char* value);
inline void set_value(const char* value, size_t size);
inline ::std::string* mutable_value();
-
- // optional bytes value_bytes = 3;
- inline bool has_value_bytes() const;
- inline void clear_value_bytes();
- static const int kValueBytesFieldNumber = 3;
- inline const ::std::string& value_bytes() const;
- inline void set_value_bytes(const ::std::string& value);
- inline void set_value_bytes(const char* value);
- inline void set_value_bytes(const void* value, size_t size);
- inline ::std::string* mutable_value_bytes();
-
+ 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_;
- mutable int _cached_size_;
-
+
::std::string* name_;
- static const ::std::string _default_name_;
::std::string* value_;
- static const ::std::string _default_value_;
- ::std::string* value_bytes_;
- static const ::std::string _default_value_bytes_;
+ ::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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static XAttr* default_instance_;
};
@@ -674,29 +685,29 @@ 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);
@@ -704,7 +715,7 @@ class Volume : public ::google::protobuf::Message {
void MergeFrom(const Volume& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -717,27 +728,29 @@ class Volume : public ::google::protobuf::Message {
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);
-
+ 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();
@@ -747,14 +760,16 @@ class Volume : public ::google::protobuf::Message {
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();
@@ -764,7 +779,9 @@ class Volume : public ::google::protobuf::Message {
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();
@@ -774,7 +791,9 @@ class Volume : public ::google::protobuf::Message {
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();
@@ -784,7 +803,9 @@ class Volume : public ::google::protobuf::Message {
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();
@@ -796,41 +817,42 @@ class Volume : public ::google::protobuf::Message {
attrs() const;
inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >*
mutable_attrs();
-
+
// @@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();
+
::google::protobuf::UnknownFieldSet _unknown_fields_;
- mutable int _cached_size_;
-
- int access_control_policy_;
+
::xtreemfs::pbrpc::StripingPolicy* default_striping_policy_;
- ::std::string* id_;
- static const ::std::string _default_id_;
+ int access_control_policy_;
::google::protobuf::uint32 mode_;
+ ::std::string* id_;
::std::string* name_;
- static const ::std::string _default_name_;
::std::string* owner_group_id_;
- static const ::std::string _default_owner_group_id_;
::std::string* owner_user_id_;
- static const ::std::string _default_owner_user_id_;
::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair > attrs_;
+
+ mutable int _cached_size_;
+ ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
+
friend void protobuf_AddDesc_xtreemfs_2fMRC_2eproto();
friend void protobuf_AssignDesc_xtreemfs_2fMRC_2eproto();
friend void protobuf_ShutdownFile_xtreemfs_2fMRC_2eproto();
-
- ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Volume* default_instance_;
};
@@ -840,29 +862,29 @@ 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);
@@ -870,7 +892,7 @@ class Volumes : public ::google::protobuf::Message {
void MergeFrom(const Volumes& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -883,13 +905,13 @@ class Volumes : public ::google::protobuf::Message {
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();
@@ -901,30 +923,21 @@ class Volumes : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static Volumes* default_instance_;
};
@@ -934,29 +947,29 @@ 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);
@@ -964,7 +977,7 @@ class StatVFS : public ::google::protobuf::Message {
void MergeFrom(const StatVFS& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -977,34 +990,41 @@ class StatVFS : public ::google::protobuf::Message {
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();
@@ -1014,42 +1034,46 @@ class StatVFS : public ::google::protobuf::Message {
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);
-
+ 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();
@@ -1059,7 +1083,9 @@ class StatVFS : public ::google::protobuf::Message {
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();
@@ -1069,7 +1095,9 @@ class StatVFS : public ::google::protobuf::Message {
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();
@@ -1079,45 +1107,61 @@ class StatVFS : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
- ::google::protobuf::uint32 bsize_;
+
::google::protobuf::uint64 bavail_;
+ ::google::protobuf::uint64 bfree_;
+ ::google::protobuf::uint32 bsize_;
+ ::google::protobuf::uint32 namemax_;
::google::protobuf::uint64 blocks_;
::std::string* fsid_;
- static const ::std::string _default_fsid_;
- ::google::protobuf::uint32 namemax_;
- int access_control_policy_;
::xtreemfs::pbrpc::StripingPolicy* default_striping_policy_;
- ::google::protobuf::uint64 etag_;
+ int access_control_policy_;
::google::protobuf::uint32 mode_;
+ ::google::protobuf::uint64 etag_;
::std::string* name_;
- static const ::std::string _default_name_;
::std::string* owner_group_id_;
- static const ::std::string _default_owner_group_id_;
::std::string* owner_user_id_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(12 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static StatVFS* default_instance_;
};
@@ -1127,29 +1171,29 @@ 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);
@@ -1157,7 +1201,7 @@ class fsetattrRequest : public ::google::protobuf::Message {
void MergeFrom(const fsetattrRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1170,59 +1214,60 @@ class fsetattrRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::xtreemfs::pbrpc::Stat* stbuf_;
- ::google::protobuf::uint32 to_set_;
::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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static fsetattrRequest* default_instance_;
};
@@ -1232,29 +1277,29 @@ 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);
@@ -1262,7 +1307,7 @@ class getattrRequest : public ::google::protobuf::Message {
void MergeFrom(const getattrRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1275,13 +1320,13 @@ class getattrRequest : public ::google::protobuf::Message {
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();
@@ -1291,7 +1336,9 @@ class getattrRequest : public ::google::protobuf::Message {
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();
@@ -1301,41 +1348,38 @@ class getattrRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static getattrRequest* default_instance_;
};
@@ -1345,29 +1389,29 @@ 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);
@@ -1375,7 +1419,7 @@ class getattrResponse : public ::google::protobuf::Message {
void MergeFrom(const getattrResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1388,43 +1432,38 @@ class getattrResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static getattrResponse* default_instance_;
};
@@ -1434,29 +1473,29 @@ 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);
@@ -1464,7 +1503,7 @@ class getxattrRequest : public ::google::protobuf::Message {
void MergeFrom(const getxattrRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1477,13 +1516,13 @@ class getxattrRequest : public ::google::protobuf::Message {
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();
@@ -1493,7 +1532,9 @@ class getxattrRequest : public ::google::protobuf::Message {
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();
@@ -1503,7 +1544,9 @@ class getxattrRequest : public ::google::protobuf::Message {
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();
@@ -1513,35 +1556,31 @@ class getxattrRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_path_;
::std::string* name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static getxattrRequest* default_instance_;
};
@@ -1551,29 +1590,29 @@ 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);
@@ -1581,7 +1620,7 @@ class getxattrResponse : public ::google::protobuf::Message {
void MergeFrom(const getxattrResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1594,13 +1633,13 @@ class getxattrResponse : public ::google::protobuf::Message {
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();
@@ -1610,43 +1649,40 @@ class getxattrResponse : public ::google::protobuf::Message {
inline void set_value(const char* value);
inline void set_value(const char* value, size_t size);
inline ::std::string* mutable_value();
-
- // optional bytes value_bytes = 2;
- inline bool has_value_bytes() const;
- inline void clear_value_bytes();
- static const int kValueBytesFieldNumber = 2;
- inline const ::std::string& value_bytes() const;
- inline void set_value_bytes(const ::std::string& value);
- inline void set_value_bytes(const char* value);
- inline void set_value_bytes(const void* value, size_t size);
- inline ::std::string* mutable_value_bytes();
-
+ 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_;
- mutable int _cached_size_;
-
+
::std::string* value_;
- static const ::std::string _default_value_;
- ::std::string* value_bytes_;
- static const ::std::string _default_value_bytes_;
+ ::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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static getxattrResponse* default_instance_;
};
@@ -1656,29 +1692,29 @@ 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);
@@ -1686,7 +1722,7 @@ class linkRequest : public ::google::protobuf::Message {
void MergeFrom(const linkRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1699,13 +1735,13 @@ class linkRequest : public ::google::protobuf::Message {
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();
@@ -1715,7 +1751,9 @@ class linkRequest : public ::google::protobuf::Message {
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();
@@ -1725,7 +1763,9 @@ class linkRequest : public ::google::protobuf::Message {
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();
@@ -1735,35 +1775,31 @@ class linkRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* target_path_;
- static const ::std::string _default_target_path_;
::std::string* link_path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static linkRequest* default_instance_;
};
@@ -1773,29 +1809,29 @@ 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);
@@ -1803,7 +1839,7 @@ class listxattrRequest : public ::google::protobuf::Message {
void MergeFrom(const listxattrRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1816,13 +1852,13 @@ class listxattrRequest : public ::google::protobuf::Message {
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();
@@ -1832,7 +1868,9 @@ class listxattrRequest : public ::google::protobuf::Message {
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();
@@ -1842,41 +1880,38 @@ class listxattrRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static listxattrRequest* default_instance_;
};
@@ -1886,29 +1921,29 @@ 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);
@@ -1916,7 +1951,7 @@ class listxattrResponse : public ::google::protobuf::Message {
void MergeFrom(const listxattrResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -1929,13 +1964,13 @@ class listxattrResponse : public ::google::protobuf::Message {
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();
@@ -1947,30 +1982,21 @@ class listxattrResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static listxattrResponse* default_instance_;
};
@@ -1980,29 +2006,29 @@ 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);
@@ -2010,7 +2036,7 @@ class mkdirRequest : public ::google::protobuf::Message {
void MergeFrom(const mkdirRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2023,13 +2049,13 @@ class mkdirRequest : public ::google::protobuf::Message {
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();
@@ -2039,7 +2065,9 @@ class mkdirRequest : public ::google::protobuf::Message {
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();
@@ -2049,41 +2077,38 @@ class mkdirRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static mkdirRequest* default_instance_;
};
@@ -2093,29 +2118,29 @@ 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);
@@ -2123,7 +2148,7 @@ class openRequest : public ::google::protobuf::Message {
void MergeFrom(const openRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2136,13 +2161,13 @@ class openRequest : public ::google::protobuf::Message {
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();
@@ -2152,7 +2177,9 @@ class openRequest : public ::google::protobuf::Message {
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();
@@ -2162,65 +2189,70 @@ class openRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_path_;
::google::protobuf::uint32 flags_;
::google::protobuf::uint32 mode_;
- ::google::protobuf::uint32 attributes_;
::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();
-
- ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static openRequest* default_instance_;
};
@@ -2230,29 +2262,29 @@ 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);
@@ -2260,7 +2292,7 @@ class openResponse : public ::google::protobuf::Message {
void MergeFrom(const openResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2273,51 +2305,48 @@ class openResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static openResponse* default_instance_;
};
@@ -2327,29 +2356,29 @@ 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);
@@ -2357,7 +2386,7 @@ class readdirRequest : public ::google::protobuf::Message {
void MergeFrom(const readdirRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2370,13 +2399,13 @@ class readdirRequest : public ::google::protobuf::Message {
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();
@@ -2386,7 +2415,9 @@ class readdirRequest : public ::google::protobuf::Message {
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();
@@ -2396,65 +2427,68 @@ class readdirRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static readdirRequest* default_instance_;
};
@@ -2464,29 +2498,29 @@ 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);
@@ -2494,7 +2528,7 @@ class readlinkRequest : public ::google::protobuf::Message {
void MergeFrom(const readlinkRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2507,13 +2541,13 @@ class readlinkRequest : public ::google::protobuf::Message {
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();
@@ -2523,7 +2557,9 @@ class readlinkRequest : public ::google::protobuf::Message {
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();
@@ -2533,33 +2569,28 @@ class readlinkRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static readlinkRequest* default_instance_;
};
@@ -2569,29 +2600,29 @@ 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);
@@ -2599,7 +2630,7 @@ class readlinkResponse : public ::google::protobuf::Message {
void MergeFrom(const readlinkResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2612,13 +2643,13 @@ class readlinkResponse : public ::google::protobuf::Message {
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();
@@ -2634,30 +2665,21 @@ class readlinkResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static readlinkResponse* default_instance_;
};
@@ -2667,29 +2689,29 @@ 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);
@@ -2697,7 +2719,7 @@ class removexattrRequest : public ::google::protobuf::Message {
void MergeFrom(const removexattrRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2710,13 +2732,13 @@ class removexattrRequest : public ::google::protobuf::Message {
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();
@@ -2726,7 +2748,9 @@ class removexattrRequest : public ::google::protobuf::Message {
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();
@@ -2736,7 +2760,9 @@ class removexattrRequest : public ::google::protobuf::Message {
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();
@@ -2746,35 +2772,31 @@ class removexattrRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_path_;
::std::string* name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static removexattrRequest* default_instance_;
};
@@ -2784,29 +2806,29 @@ 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);
@@ -2814,7 +2836,7 @@ class renameRequest : public ::google::protobuf::Message {
void MergeFrom(const renameRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2827,13 +2849,13 @@ class renameRequest : public ::google::protobuf::Message {
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();
@@ -2843,7 +2865,9 @@ class renameRequest : public ::google::protobuf::Message {
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();
@@ -2853,7 +2877,9 @@ class renameRequest : public ::google::protobuf::Message {
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();
@@ -2863,35 +2889,31 @@ class renameRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* source_path_;
- static const ::std::string _default_source_path_;
::std::string* target_path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static renameRequest* default_instance_;
};
@@ -2901,29 +2923,29 @@ 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);
@@ -2931,7 +2953,7 @@ class renameResponse : public ::google::protobuf::Message {
void MergeFrom(const renameResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -2944,51 +2966,48 @@ class renameResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
- ::google::protobuf::uint32 timestamp_s_;
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static renameResponse* default_instance_;
};
@@ -2998,29 +3017,29 @@ 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);
@@ -3028,7 +3047,7 @@ class rmdirRequest : public ::google::protobuf::Message {
void MergeFrom(const rmdirRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3041,13 +3060,13 @@ class rmdirRequest : public ::google::protobuf::Message {
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();
@@ -3057,7 +3076,9 @@ class rmdirRequest : public ::google::protobuf::Message {
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();
@@ -3067,33 +3088,28 @@ class rmdirRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static rmdirRequest* default_instance_;
};
@@ -3103,29 +3119,29 @@ 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);
@@ -3133,7 +3149,7 @@ class setattrRequest : public ::google::protobuf::Message {
void MergeFrom(const setattrRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3146,13 +3162,13 @@ class setattrRequest : public ::google::protobuf::Message {
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();
@@ -3162,7 +3178,9 @@ class setattrRequest : public ::google::protobuf::Message {
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();
@@ -3172,49 +3190,50 @@ class setattrRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static setattrRequest* default_instance_;
};
@@ -3224,29 +3243,29 @@ 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);
@@ -3254,7 +3273,7 @@ class setxattrRequest : public ::google::protobuf::Message {
void MergeFrom(const setxattrRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3267,13 +3286,13 @@ class setxattrRequest : public ::google::protobuf::Message {
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();
@@ -3283,7 +3302,9 @@ class setxattrRequest : public ::google::protobuf::Message {
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();
@@ -3293,7 +3314,9 @@ class setxattrRequest : public ::google::protobuf::Message {
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();
@@ -3303,7 +3326,9 @@ class setxattrRequest : public ::google::protobuf::Message {
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();
@@ -3313,57 +3338,59 @@ class setxattrRequest : public ::google::protobuf::Message {
inline void set_value(const char* value);
inline void set_value(const char* value, size_t size);
inline ::std::string* mutable_value();
-
- // optional bytes value_bytes = 6;
- inline bool has_value_bytes() const;
- inline void clear_value_bytes();
- static const int kValueBytesFieldNumber = 6;
- inline const ::std::string& value_bytes() const;
- inline void set_value_bytes(const ::std::string& value);
- inline void set_value_bytes(const char* value);
- inline void set_value_bytes(const void* value, size_t size);
- inline ::std::string* mutable_value_bytes();
-
+ 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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_path_;
::std::string* name_;
- static const ::std::string _default_name_;
::std::string* value_;
- static const ::std::string _default_value_;
- ::std::string* value_bytes_;
- static const ::std::string _default_value_bytes_;
+ ::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();
-
- ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static setxattrRequest* default_instance_;
};
@@ -3373,29 +3400,29 @@ 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);
@@ -3403,7 +3430,7 @@ class statvfsRequest : public ::google::protobuf::Message {
void MergeFrom(const statvfsRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3416,13 +3443,13 @@ class statvfsRequest : public ::google::protobuf::Message {
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();
@@ -3432,39 +3459,35 @@ class statvfsRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static statvfsRequest* default_instance_;
};
@@ -3474,29 +3497,29 @@ 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);
@@ -3504,7 +3527,7 @@ class symlinkRequest : public ::google::protobuf::Message {
void MergeFrom(const symlinkRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3517,13 +3540,13 @@ class symlinkRequest : public ::google::protobuf::Message {
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();
@@ -3533,7 +3556,9 @@ class symlinkRequest : public ::google::protobuf::Message {
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();
@@ -3543,7 +3568,9 @@ class symlinkRequest : public ::google::protobuf::Message {
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();
@@ -3553,35 +3580,31 @@ class symlinkRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* target_path_;
- static const ::std::string _default_target_path_;
::std::string* link_path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static symlinkRequest* default_instance_;
};
@@ -3591,29 +3614,29 @@ 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);
@@ -3621,7 +3644,7 @@ class unlinkRequest : public ::google::protobuf::Message {
void MergeFrom(const unlinkRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3634,13 +3657,13 @@ class unlinkRequest : public ::google::protobuf::Message {
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();
@@ -3650,7 +3673,9 @@ class unlinkRequest : public ::google::protobuf::Message {
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();
@@ -3660,33 +3685,28 @@ class unlinkRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static unlinkRequest* default_instance_;
};
@@ -3696,29 +3716,29 @@ 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);
@@ -3726,7 +3746,7 @@ class unlinkResponse : public ::google::protobuf::Message {
void MergeFrom(const unlinkResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3739,51 +3759,48 @@ class unlinkResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
- ::google::protobuf::uint32 timestamp_s_;
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static unlinkResponse* default_instance_;
};
@@ -3793,29 +3810,29 @@ 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);
@@ -3823,7 +3840,7 @@ class accessRequest : public ::google::protobuf::Message {
void MergeFrom(const accessRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3836,13 +3853,13 @@ class accessRequest : public ::google::protobuf::Message {
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();
@@ -3852,7 +3869,9 @@ class accessRequest : public ::google::protobuf::Message {
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();
@@ -3862,41 +3881,38 @@ class accessRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static accessRequest* default_instance_;
};
@@ -3906,29 +3922,29 @@ 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);
@@ -3936,7 +3952,7 @@ class xtreemfs_check_file_existsRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_check_file_existsRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -3949,13 +3965,13 @@ class xtreemfs_check_file_existsRequest : public ::google::protobuf::Message {
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();
@@ -3965,7 +3981,9 @@ class xtreemfs_check_file_existsRequest : public ::google::protobuf::Message {
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();
@@ -3981,7 +3999,7 @@ class xtreemfs_check_file_existsRequest : public ::google::protobuf::Message {
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();
@@ -3991,34 +4009,29 @@ class xtreemfs_check_file_existsRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_id_;
- static const ::std::string _default_volume_id_;
::google::protobuf::RepeatedPtrField< ::std::string> file_ids_;
::std::string* osd_uuid_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_check_file_existsRequest* default_instance_;
};
@@ -4028,29 +4041,29 @@ 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);
@@ -4058,7 +4071,7 @@ class xtreemfs_dump_restore_databaseRequest : public ::google::protobuf::Message
void MergeFrom(const xtreemfs_dump_restore_databaseRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4071,13 +4084,13 @@ class xtreemfs_dump_restore_databaseRequest : public ::google::protobuf::Message
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();
@@ -4087,31 +4100,25 @@ class xtreemfs_dump_restore_databaseRequest : public ::google::protobuf::Message
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_;
- mutable int _cached_size_;
-
+
::std::string* dump_file_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_dump_restore_databaseRequest* default_instance_;
};
@@ -4121,29 +4128,29 @@ 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);
@@ -4151,7 +4158,7 @@ class xtreemfs_get_suitable_osdsRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_get_suitable_osdsRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4164,13 +4171,13 @@ class xtreemfs_get_suitable_osdsRequest : public ::google::protobuf::Message {
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();
@@ -4180,7 +4187,9 @@ class xtreemfs_get_suitable_osdsRequest : public ::google::protobuf::Message {
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();
@@ -4190,7 +4199,9 @@ class xtreemfs_get_suitable_osdsRequest : public ::google::protobuf::Message {
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();
@@ -4200,43 +4211,41 @@ class xtreemfs_get_suitable_osdsRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* file_id_;
- static const ::std::string _default_file_id_;
::std::string* path_;
- static const ::std::string _default_path_;
::std::string* volume_name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_get_suitable_osdsRequest* default_instance_;
};
@@ -4246,29 +4255,29 @@ 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);
@@ -4276,7 +4285,7 @@ class xtreemfs_get_suitable_osdsResponse : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_get_suitable_osdsResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4289,13 +4298,13 @@ class xtreemfs_get_suitable_osdsResponse : public ::google::protobuf::Message {
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();
@@ -4311,30 +4320,21 @@ class xtreemfs_get_suitable_osdsResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_get_suitable_osdsResponse* default_instance_;
};
@@ -4344,29 +4344,29 @@ 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);
@@ -4374,7 +4374,7 @@ class xtreemfs_check_file_existsResponse : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_check_file_existsResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4387,13 +4387,13 @@ class xtreemfs_check_file_existsResponse : public ::google::protobuf::Message {
void SharedDtor();
void SetCachedSize(int size) const;
public:
-
+
::google::protobuf::Metadata GetMetadata() const;
-
+
// nested types ----------------------------------------------------
-
+
// accessors -------------------------------------------------------
-
+
// required string bitmap = 1;
inline bool has_bitmap() const;
inline void clear_bitmap();
@@ -4403,31 +4403,25 @@ class xtreemfs_check_file_existsResponse : public ::google::protobuf::Message {
inline void set_bitmap(const char* value);
inline void set_bitmap(const char* value, size_t size);
inline ::std::string* mutable_bitmap();
-
+ inline ::std::string* release_bitmap();
+ inline void set_allocated_bitmap(::std::string* bitmap);
+
// @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.xtreemfs_check_file_existsResponse)
private:
+ inline void set_has_bitmap();
+ inline void clear_has_bitmap();
+
::google::protobuf::UnknownFieldSet _unknown_fields_;
- mutable int _cached_size_;
-
+
::std::string* bitmap_;
- static const ::std::string _default_bitmap_;
+
+ 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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_check_file_existsResponse* default_instance_;
};
@@ -4437,29 +4431,29 @@ 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);
@@ -4467,7 +4461,7 @@ class timestampResponse : public ::google::protobuf::Message {
void MergeFrom(const timestampResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4480,43 +4474,36 @@ class timestampResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static timestampResponse* default_instance_;
};
@@ -4526,29 +4513,29 @@ 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);
@@ -4556,7 +4543,7 @@ class stringMessage : public ::google::protobuf::Message {
void MergeFrom(const stringMessage& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4569,13 +4556,13 @@ class stringMessage : public ::google::protobuf::Message {
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();
@@ -4585,31 +4572,25 @@ class stringMessage : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* a_string_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static stringMessage* default_instance_;
};
@@ -4619,29 +4600,29 @@ 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);
@@ -4649,7 +4630,7 @@ class xtreemfs_listdirRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_listdirRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4662,13 +4643,13 @@ class xtreemfs_listdirRequest : public ::google::protobuf::Message {
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();
@@ -4678,31 +4659,25 @@ class xtreemfs_listdirRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* path_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_listdirRequest* default_instance_;
};
@@ -4712,29 +4687,29 @@ 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);
@@ -4742,7 +4717,7 @@ class xtreemfs_listdirResponse : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_listdirResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4755,13 +4730,13 @@ class xtreemfs_listdirResponse : public ::google::protobuf::Message {
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();
@@ -4777,30 +4752,21 @@ class xtreemfs_listdirResponse : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_listdirResponse* default_instance_;
};
@@ -4810,29 +4776,29 @@ 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);
@@ -4840,7 +4806,7 @@ class xtreemfs_replica_addRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_replica_addRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4853,13 +4819,13 @@ class xtreemfs_replica_addRequest : public ::google::protobuf::Message {
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();
@@ -4869,7 +4835,9 @@ class xtreemfs_replica_addRequest : public ::google::protobuf::Message {
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();
@@ -4879,7 +4847,9 @@ class xtreemfs_replica_addRequest : public ::google::protobuf::Message {
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();
@@ -4889,43 +4859,43 @@ class xtreemfs_replica_addRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* file_id_;
- static const ::std::string _default_file_id_;
::std::string* path_;
- static const ::std::string _default_path_;
::std::string* volume_name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_replica_addRequest* default_instance_;
};
@@ -4935,29 +4905,29 @@ 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);
@@ -4965,7 +4935,7 @@ class xtreemfs_replica_listRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_replica_listRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -4978,13 +4948,13 @@ class xtreemfs_replica_listRequest : public ::google::protobuf::Message {
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();
@@ -4994,7 +4964,9 @@ class xtreemfs_replica_listRequest : public ::google::protobuf::Message {
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();
@@ -5004,7 +4976,9 @@ class xtreemfs_replica_listRequest : public ::google::protobuf::Message {
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();
@@ -5014,35 +4988,31 @@ class xtreemfs_replica_listRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* file_id_;
- static const ::std::string _default_file_id_;
::std::string* path_;
- static const ::std::string _default_path_;
::std::string* volume_name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_replica_listRequest* default_instance_;
};
@@ -5052,29 +5022,29 @@ 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);
@@ -5082,7 +5052,7 @@ class xtreemfs_replica_removeRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_replica_removeRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5095,13 +5065,13 @@ class xtreemfs_replica_removeRequest : public ::google::protobuf::Message {
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();
@@ -5111,7 +5081,9 @@ class xtreemfs_replica_removeRequest : public ::google::protobuf::Message {
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();
@@ -5121,7 +5093,9 @@ class xtreemfs_replica_removeRequest : public ::google::protobuf::Message {
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();
@@ -5131,7 +5105,9 @@ class xtreemfs_replica_removeRequest : public ::google::protobuf::Message {
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();
@@ -5141,37 +5117,34 @@ class xtreemfs_replica_removeRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* file_id_;
- static const ::std::string _default_file_id_;
::std::string* path_;
- static const ::std::string _default_path_;
::std::string* volume_name_;
- static const ::std::string _default_volume_name_;
::std::string* osd_uuid_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_replica_removeRequest* default_instance_;
};
@@ -5181,29 +5154,29 @@ 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);
@@ -5211,7 +5184,7 @@ class xtreemfs_restore_fileRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_restore_fileRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5224,13 +5197,13 @@ class xtreemfs_restore_fileRequest : public ::google::protobuf::Message {
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();
@@ -5240,7 +5213,9 @@ class xtreemfs_restore_fileRequest : public ::google::protobuf::Message {
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();
@@ -5250,14 +5225,16 @@ class xtreemfs_restore_fileRequest : public ::google::protobuf::Message {
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();
@@ -5267,44 +5244,44 @@ class xtreemfs_restore_fileRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* file_path_;
- static const ::std::string _default_file_path_;
::std::string* file_id_;
- static const ::std::string _default_file_id_;
::google::protobuf::uint64 file_size_;
::std::string* osd_uuid_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_restore_fileRequest* default_instance_;
};
@@ -5314,29 +5291,29 @@ 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);
@@ -5344,7 +5321,7 @@ class xtreemfs_rmvolRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_rmvolRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5357,13 +5334,13 @@ class xtreemfs_rmvolRequest : public ::google::protobuf::Message {
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();
@@ -5373,31 +5350,25 @@ class xtreemfs_rmvolRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* volume_name_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_rmvolRequest* default_instance_;
};
@@ -5407,29 +5378,29 @@ 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);
@@ -5437,7 +5408,7 @@ class xtreemfs_update_file_sizeRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_update_file_sizeRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5450,67 +5421,72 @@ class xtreemfs_update_file_sizeRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::xtreemfs::pbrpc::XCap* xcap_;
::xtreemfs::pbrpc::OSDWriteResponse* osd_write_response_;
- bool close_file_;
::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();
-
- ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_update_file_sizeRequest* default_instance_;
};
@@ -5520,29 +5496,29 @@ class xtreemfs_set_replica_update_policyRequest : public ::google::protobuf::Mes
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);
@@ -5550,7 +5526,7 @@ class xtreemfs_set_replica_update_policyRequest : public ::google::protobuf::Mes
void MergeFrom(const xtreemfs_set_replica_update_policyRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5563,13 +5539,13 @@ class xtreemfs_set_replica_update_policyRequest : public ::google::protobuf::Mes
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();
@@ -5579,7 +5555,9 @@ class xtreemfs_set_replica_update_policyRequest : public ::google::protobuf::Mes
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();
@@ -5589,33 +5567,28 @@ class xtreemfs_set_replica_update_policyRequest : public ::google::protobuf::Mes
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_;
- mutable int _cached_size_;
-
+
::std::string* file_id_;
- static const ::std::string _default_file_id_;
::std::string* update_policy_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_set_replica_update_policyRequest* default_instance_;
};
@@ -5625,29 +5598,29 @@ class xtreemfs_set_replica_update_policyResponse : public ::google::protobuf::Me
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);
@@ -5655,7 +5628,7 @@ class xtreemfs_set_replica_update_policyResponse : public ::google::protobuf::Me
void MergeFrom(const xtreemfs_set_replica_update_policyResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5668,13 +5641,13 @@ class xtreemfs_set_replica_update_policyResponse : public ::google::protobuf::Me
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();
@@ -5684,31 +5657,25 @@ class xtreemfs_set_replica_update_policyResponse : public ::google::protobuf::Me
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_;
- mutable int _cached_size_;
-
+
::std::string* old_update_policy_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_set_replica_update_policyResponse* default_instance_;
};
@@ -5718,29 +5685,29 @@ 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);
@@ -5748,7 +5715,7 @@ class xtreemfs_set_read_only_xattrRequest : public ::google::protobuf::Message {
void MergeFrom(const xtreemfs_set_read_only_xattrRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5761,13 +5728,13 @@ class xtreemfs_set_read_only_xattrRequest : public ::google::protobuf::Message {
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();
@@ -5777,39 +5744,35 @@ class xtreemfs_set_read_only_xattrRequest : public ::google::protobuf::Message {
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_;
- mutable int _cached_size_;
-
+
::std::string* file_id_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_set_read_only_xattrRequest* default_instance_;
};
@@ -5819,29 +5782,29 @@ 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);
@@ -5849,7 +5812,7 @@ class xtreemfs_set_read_only_xattrResponse : public ::google::protobuf::Message
void MergeFrom(const xtreemfs_set_read_only_xattrResponse& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5862,43 +5825,36 @@ class xtreemfs_set_read_only_xattrResponse : public ::google::protobuf::Message
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_;
- mutable int _cached_size_;
-
+
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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_set_read_only_xattrResponse* default_instance_;
};
@@ -5908,29 +5864,29 @@ 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);
@@ -5938,7 +5894,7 @@ class xtreemfs_get_file_credentialsRequest : public ::google::protobuf::Message
void MergeFrom(const xtreemfs_get_file_credentialsRequest& from);
void Clear();
bool IsInitialized() const;
-
+
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
@@ -5951,13 +5907,13 @@ class xtreemfs_get_file_credentialsRequest : public ::google::protobuf::Message
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();
@@ -5967,407 +5923,30 @@ class xtreemfs_get_file_credentialsRequest : public ::google::protobuf::Message
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_;
- mutable int _cached_size_;
-
+
::std::string* file_id_;
- static const ::std::string _default_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();
-
- ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
- // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
- inline bool _has_bit(int index) const {
- return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
- }
- inline void _set_bit(int index) {
- _has_bits_[index / 32] |= (1u << (index % 32));
- }
- inline void _clear_bit(int index) {
- _has_bits_[index / 32] &= ~(1u << (index % 32));
- }
-
+
void InitAsDefaultInstance();
static xtreemfs_get_file_credentialsRequest* default_instance_;
};
// ===================================================================
-class MRCService_Stub;
-
-class MRCService : public ::google::protobuf::Service {
- protected:
- // This class should be treated as an abstract interface.
- inline MRCService() {};
- public:
- virtual ~MRCService();
-
- typedef MRCService_Stub Stub;
-
- static const ::google::protobuf::ServiceDescriptor* descriptor();
-
- virtual void fsetattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::fsetattrRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void ftruncate(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::XCap* request,
- ::xtreemfs::pbrpc::XCap* response,
- ::google::protobuf::Closure* done);
- virtual void getattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::getattrRequest* request,
- ::xtreemfs::pbrpc::getattrResponse* response,
- ::google::protobuf::Closure* done);
- virtual void getxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::getxattrRequest* request,
- ::xtreemfs::pbrpc::getxattrResponse* response,
- ::google::protobuf::Closure* done);
- virtual void link(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::linkRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- virtual void listxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::listxattrRequest* request,
- ::xtreemfs::pbrpc::listxattrResponse* response,
- ::google::protobuf::Closure* done);
- virtual void mkdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::mkdirRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- virtual void open(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::openRequest* request,
- ::xtreemfs::pbrpc::openResponse* response,
- ::google::protobuf::Closure* done);
- virtual void readdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::readdirRequest* request,
- ::xtreemfs::pbrpc::DirectoryEntries* response,
- ::google::protobuf::Closure* done);
- virtual void readlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::readlinkRequest* request,
- ::xtreemfs::pbrpc::readlinkResponse* response,
- ::google::protobuf::Closure* done);
- virtual void removexattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::removexattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- virtual void rename(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::renameRequest* request,
- ::xtreemfs::pbrpc::renameResponse* response,
- ::google::protobuf::Closure* done);
- virtual void rmdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::rmdirRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- virtual void setattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::setattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- virtual void setxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::setxattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- virtual void statvfs(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::statvfsRequest* request,
- ::xtreemfs::pbrpc::StatVFS* response,
- ::google::protobuf::Closure* done);
- virtual void symlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::symlinkRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- virtual void unlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::unlinkRequest* request,
- ::xtreemfs::pbrpc::unlinkResponse* response,
- ::google::protobuf::Closure* done);
- virtual void access(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::accessRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_checkpoint(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_check_file_exists(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_check_file_existsRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_dump_database(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_get_suitable_osds(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_internal_debug(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::stringMessage* request,
- ::xtreemfs::pbrpc::stringMessage* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_listdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_listdirRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_listdirResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_lsvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::Volumes* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_mkvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Volume* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_renew_capability(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::XCap* request,
- ::xtreemfs::pbrpc::XCap* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_replication_to_master(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_replica_add(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_addRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_replica_list(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_listRequest* request,
- ::xtreemfs::pbrpc::Replicas* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_replica_remove(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_removeRequest* request,
- ::xtreemfs::pbrpc::FileCredentials* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_restore_database(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_restore_file(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_restore_fileRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_rmvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_rmvolRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_shutdown(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_update_file_size(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_update_file_sizeRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_set_replica_update_policy(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_set_read_only_xattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrResponse* response,
- ::google::protobuf::Closure* done);
- virtual void xtreemfs_get_file_credentials(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_get_file_credentialsRequest* request,
- ::xtreemfs::pbrpc::FileCredentials* response,
- ::google::protobuf::Closure* done);
-
- // implements Service ----------------------------------------------
-
- const ::google::protobuf::ServiceDescriptor* GetDescriptor();
- void CallMethod(const ::google::protobuf::MethodDescriptor* method,
- ::google::protobuf::RpcController* controller,
- const ::google::protobuf::Message* request,
- ::google::protobuf::Message* response,
- ::google::protobuf::Closure* done);
- const ::google::protobuf::Message& GetRequestPrototype(
- const ::google::protobuf::MethodDescriptor* method) const;
- const ::google::protobuf::Message& GetResponsePrototype(
- const ::google::protobuf::MethodDescriptor* method) const;
-
- private:
- GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MRCService);
-};
-
-class MRCService_Stub : public MRCService {
- public:
- MRCService_Stub(::google::protobuf::RpcChannel* channel);
- MRCService_Stub(::google::protobuf::RpcChannel* channel,
- ::google::protobuf::Service::ChannelOwnership ownership);
- ~MRCService_Stub();
-
- inline ::google::protobuf::RpcChannel* channel() { return channel_; }
-
- // implements MRCService ------------------------------------------
-
- void fsetattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::fsetattrRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void ftruncate(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::XCap* request,
- ::xtreemfs::pbrpc::XCap* response,
- ::google::protobuf::Closure* done);
- void getattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::getattrRequest* request,
- ::xtreemfs::pbrpc::getattrResponse* response,
- ::google::protobuf::Closure* done);
- void getxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::getxattrRequest* request,
- ::xtreemfs::pbrpc::getxattrResponse* response,
- ::google::protobuf::Closure* done);
- void link(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::linkRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- void listxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::listxattrRequest* request,
- ::xtreemfs::pbrpc::listxattrResponse* response,
- ::google::protobuf::Closure* done);
- void mkdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::mkdirRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- void open(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::openRequest* request,
- ::xtreemfs::pbrpc::openResponse* response,
- ::google::protobuf::Closure* done);
- void readdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::readdirRequest* request,
- ::xtreemfs::pbrpc::DirectoryEntries* response,
- ::google::protobuf::Closure* done);
- void readlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::readlinkRequest* request,
- ::xtreemfs::pbrpc::readlinkResponse* response,
- ::google::protobuf::Closure* done);
- void removexattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::removexattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- void rename(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::renameRequest* request,
- ::xtreemfs::pbrpc::renameResponse* response,
- ::google::protobuf::Closure* done);
- void rmdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::rmdirRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- void setattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::setattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- void setxattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::setxattrRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- void statvfs(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::statvfsRequest* request,
- ::xtreemfs::pbrpc::StatVFS* response,
- ::google::protobuf::Closure* done);
- void symlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::symlinkRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- void unlink(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::unlinkRequest* request,
- ::xtreemfs::pbrpc::unlinkResponse* response,
- ::google::protobuf::Closure* done);
- void access(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::accessRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_checkpoint(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_check_file_exists(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_check_file_existsRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_check_file_existsResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_dump_database(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_get_suitable_osds(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_get_suitable_osdsResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_internal_debug(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::stringMessage* request,
- ::xtreemfs::pbrpc::stringMessage* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_listdir(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_listdirRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_listdirResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_lsvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::Volumes* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_mkvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::Volume* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_renew_capability(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::XCap* request,
- ::xtreemfs::pbrpc::XCap* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_replication_to_master(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_replica_add(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_addRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_replica_list(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_listRequest* request,
- ::xtreemfs::pbrpc::Replicas* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_replica_remove(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_replica_removeRequest* request,
- ::xtreemfs::pbrpc::FileCredentials* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_restore_database(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_dump_restore_databaseRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_restore_file(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_restore_fileRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_rmvol(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_rmvolRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_shutdown(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::emptyRequest* request,
- ::xtreemfs::pbrpc::emptyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_update_file_size(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_update_file_sizeRequest* request,
- ::xtreemfs::pbrpc::timestampResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_set_replica_update_policy(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_set_replica_update_policyResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_set_read_only_xattr(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrRequest* request,
- ::xtreemfs::pbrpc::xtreemfs_set_read_only_xattrResponse* response,
- ::google::protobuf::Closure* done);
- void xtreemfs_get_file_credentials(::google::protobuf::RpcController* controller,
- const ::xtreemfs::pbrpc::xtreemfs_get_file_credentialsRequest* request,
- ::xtreemfs::pbrpc::FileCredentials* response,
- ::google::protobuf::Closure* done);
- private:
- ::google::protobuf::RpcChannel* channel_;
- bool owns_channel_;
- GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MRCService_Stub);
-};
-
-
-// ===================================================================
-
// ===================================================================
@@ -6375,277 +5954,405 @@ class MRCService_Stub : public MRCService {
// required fixed64 dev = 1;
inline bool Stat::has_dev() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_dev();
}
inline ::google::protobuf::uint64 Stat::dev() const {
return dev_;
}
inline void Stat::set_dev(::google::protobuf::uint64 value) {
- _set_bit(0);
+ set_has_dev();
dev_ = value;
}
// required fixed64 ino = 2;
inline bool Stat::has_ino() const {
- return _has_bit(1);
+ 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_bit(1);
+ clear_has_ino();
}
inline ::google::protobuf::uint64 Stat::ino() const {
return ino_;
}
inline void Stat::set_ino(::google::protobuf::uint64 value) {
- _set_bit(1);
+ set_has_ino();
ino_ = value;
}
// required fixed32 mode = 3;
inline bool Stat::has_mode() const {
- return _has_bit(2);
+ 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_bit(2);
+ clear_has_mode();
}
inline ::google::protobuf::uint32 Stat::mode() const {
return mode_;
}
inline void Stat::set_mode(::google::protobuf::uint32 value) {
- _set_bit(2);
+ set_has_mode();
mode_ = value;
}
// required fixed32 nlink = 4;
inline bool Stat::has_nlink() const {
- return _has_bit(3);
+ 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_bit(3);
+ clear_has_nlink();
}
inline ::google::protobuf::uint32 Stat::nlink() const {
return nlink_;
}
inline void Stat::set_nlink(::google::protobuf::uint32 value) {
- _set_bit(3);
+ set_has_nlink();
nlink_ = value;
}
// required string user_id = 5;
inline bool Stat::has_user_id() const {
- return _has_bit(4);
+ 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_ != &_default_user_id_) {
+ if (user_id_ != &::google::protobuf::internal::kEmptyString) {
user_id_->clear();
}
- _clear_bit(4);
+ 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_bit(4);
- if (user_id_ == &_default_user_id_) {
+ 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_bit(4);
- if (user_id_ == &_default_user_id_) {
+ 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_bit(4);
- if (user_id_ == &_default_user_id_) {
+ 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_bit(4);
- if (user_id_ == &_default_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_bit(5);
+ 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_ != &_default_group_id_) {
+ if (group_id_ != &::google::protobuf::internal::kEmptyString) {
group_id_->clear();
}
- _clear_bit(5);
+ 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_bit(5);
- if (group_id_ == &_default_group_id_) {
+ 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_bit(5);
- if (group_id_ == &_default_group_id_) {
+ 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_bit(5);
- if (group_id_ == &_default_group_id_) {
+ 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_bit(5);
- if (group_id_ == &_default_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_bit(6);
+ 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_bit(6);
+ clear_has_size();
}
inline ::google::protobuf::uint64 Stat::size() const {
return size_;
}
inline void Stat::set_size(::google::protobuf::uint64 value) {
- _set_bit(6);
+ set_has_size();
size_ = value;
}
// required fixed64 atime_ns = 8;
inline bool Stat::has_atime_ns() const {
- return _has_bit(7);
+ 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_bit(7);
+ 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_bit(7);
+ set_has_atime_ns();
atime_ns_ = value;
}
// required fixed64 mtime_ns = 9;
inline bool Stat::has_mtime_ns() const {
- return _has_bit(8);
+ 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_bit(8);
+ 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_bit(8);
+ set_has_mtime_ns();
mtime_ns_ = value;
}
// required fixed64 ctime_ns = 10;
inline bool Stat::has_ctime_ns() const {
- return _has_bit(9);
+ 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_bit(9);
+ 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_bit(9);
+ set_has_ctime_ns();
ctime_ns_ = value;
}
// required fixed32 blksize = 11;
inline bool Stat::has_blksize() const {
- return _has_bit(10);
+ 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_bit(10);
+ clear_has_blksize();
}
inline ::google::protobuf::uint32 Stat::blksize() const {
return blksize_;
}
inline void Stat::set_blksize(::google::protobuf::uint32 value) {
- _set_bit(10);
+ set_has_blksize();
blksize_ = value;
}
// optional fixed64 etag = 12;
inline bool Stat::has_etag() const {
- return _has_bit(11);
+ 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_bit(11);
+ clear_has_etag();
}
inline ::google::protobuf::uint64 Stat::etag() const {
return etag_;
}
inline void Stat::set_etag(::google::protobuf::uint64 value) {
- _set_bit(11);
+ set_has_etag();
etag_ = value;
}
// required fixed32 truncate_epoch = 13;
inline bool Stat::has_truncate_epoch() const {
- return _has_bit(12);
+ 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_bit(12);
+ 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_bit(12);
+ set_has_truncate_epoch();
truncate_epoch_ = value;
}
// optional fixed32 attributes = 14;
inline bool Stat::has_attributes() const {
- return _has_bit(13);
+ 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_bit(13);
+ clear_has_attributes();
}
inline ::google::protobuf::uint32 Stat::attributes() const {
return attributes_;
}
inline void Stat::set_attributes(::google::protobuf::uint32 value) {
- _set_bit(13);
+ set_has_attributes();
attributes_ = value;
}
@@ -6655,62 +6362,111 @@ inline void Stat::set_attributes(::google::protobuf::uint32 value) {
// required string name = 1;
inline bool DirectoryEntry::has_name() const {
- return _has_bit(0);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(0);
+ clear_has_name();
}
inline const ::std::string& DirectoryEntry::name() const {
return *name_;
}
inline void DirectoryEntry::set_name(const ::std::string& value) {
- _set_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_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_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -6747,128 +6503,212 @@ DirectoryEntries::mutable_entries() {
// required string name = 1;
inline bool XAttr::has_name() const {
- return _has_bit(0);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(0);
+ clear_has_name();
}
inline const ::std::string& XAttr::name() const {
return *name_;
}
inline void XAttr::set_name(const ::std::string& value) {
- _set_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_name_) {
+ 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_bit(0);
- if (name_ == &_default_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_bit(1);
+ 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_ != &_default_value_) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
value_->clear();
}
- _clear_bit(1);
+ clear_has_value();
}
inline const ::std::string& XAttr::value() const {
return *value_;
}
inline void XAttr::set_value(const ::std::string& value) {
- _set_bit(1);
- if (value_ == &_default_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_bit(1);
- if (value_ == &_default_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_bit(1);
- if (value_ == &_default_value_) {
+ 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_bit(1);
- if (value_ == &_default_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 = 3;
-inline bool XAttr::has_value_bytes() const {
- return _has_bit(2);
+// 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::clear_value_bytes() {
- if (value_bytes_ != &_default_value_bytes_) {
- value_bytes_->clear();
+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;
}
- _clear_bit(2);
+ value_bytes_string_->assign(value);
}
-inline const ::std::string& XAttr::value_bytes() const {
- return *value_bytes_;
+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(const ::std::string& value) {
- _set_bit(2);
- if (value_bytes_ == &_default_value_bytes_) {
- value_bytes_ = new ::std::string;
+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_->assign(value);
+ value_bytes_string_->assign(reinterpret_cast(value), size);
}
-inline void XAttr::set_value_bytes(const char* value) {
- _set_bit(2);
- if (value_bytes_ == &_default_value_bytes_) {
- value_bytes_ = new ::std::string;
+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;
}
- value_bytes_->assign(value);
+ return value_bytes_string_;
}
-inline void XAttr::set_value_bytes(const void* value, size_t size) {
- _set_bit(2);
- if (value_bytes_ == &_default_value_bytes_) {
- value_bytes_ = new ::std::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;
}
- value_bytes_->assign(reinterpret_cast(value), size);
}
-inline ::std::string* XAttr::mutable_value_bytes() {
- _set_bit(2);
- if (value_bytes_ == &_default_value_bytes_) {
- value_bytes_ = new ::std::string;
+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);
}
- return value_bytes_;
}
// -------------------------------------------------------------------
@@ -6877,221 +6717,366 @@ inline ::std::string* XAttr::mutable_value_bytes() {
// required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 1;
inline bool Volume::has_access_control_policy() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_access_control_policy();
}
-inline xtreemfs::pbrpc::AccessControlPolicyType Volume::access_control_policy() const {
- return static_cast< xtreemfs::pbrpc::AccessControlPolicyType >(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) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::AccessControlPolicyType_IsValid(value));
- _set_bit(0);
+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_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ 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_bit(2);
+ 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_ != &_default_id_) {
+ if (id_ != &::google::protobuf::internal::kEmptyString) {
id_->clear();
}
- _clear_bit(2);
+ clear_has_id();
}
inline const ::std::string& Volume::id() const {
return *id_;
}
inline void Volume::set_id(const ::std::string& value) {
- _set_bit(2);
- if (id_ == &_default_id_) {
+ 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_bit(2);
- if (id_ == &_default_id_) {
+ 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_bit(2);
- if (id_ == &_default_id_) {
+ 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_bit(2);
- if (id_ == &_default_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_bit(3);
+ 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_bit(3);
+ clear_has_mode();
}
inline ::google::protobuf::uint32 Volume::mode() const {
return mode_;
}
inline void Volume::set_mode(::google::protobuf::uint32 value) {
- _set_bit(3);
+ set_has_mode();
mode_ = value;
}
// required string name = 5;
inline bool Volume::has_name() const {
- return _has_bit(4);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(4);
+ clear_has_name();
}
inline const ::std::string& Volume::name() const {
return *name_;
}
inline void Volume::set_name(const ::std::string& value) {
- _set_bit(4);
- if (name_ == &_default_name_) {
+ 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_bit(4);
- if (name_ == &_default_name_) {
+ 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_bit(4);
- if (name_ == &_default_name_) {
+ 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_bit(4);
- if (name_ == &_default_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_bit(5);
+ 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_ != &_default_owner_group_id_) {
+ if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) {
owner_group_id_->clear();
}
- _clear_bit(5);
+ 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_bit(5);
- if (owner_group_id_ == &_default_owner_group_id_) {
+ 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_bit(5);
- if (owner_group_id_ == &_default_owner_group_id_) {
+ 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_bit(5);
- if (owner_group_id_ == &_default_owner_group_id_) {
+ 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_bit(5);
- if (owner_group_id_ == &_default_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_bit(6);
+ 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_ != &_default_owner_user_id_) {
+ if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) {
owner_user_id_->clear();
}
- _clear_bit(6);
+ 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_bit(6);
- if (owner_user_id_ == &_default_owner_user_id_) {
+ 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_bit(6);
- if (owner_user_id_ == &_default_owner_user_id_) {
+ 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_bit(6);
- if (owner_user_id_ == &_default_owner_user_id_) {
+ 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_bit(6);
- if (owner_user_id_ == &_default_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 {
@@ -7153,301 +7138,498 @@ Volumes::mutable_volumes() {
// required fixed32 bsize = 1;
inline bool StatVFS::has_bsize() const {
- return _has_bit(0);
+ 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_bit(0);
+ clear_has_bsize();
}
inline ::google::protobuf::uint32 StatVFS::bsize() const {
return bsize_;
}
inline void StatVFS::set_bsize(::google::protobuf::uint32 value) {
- _set_bit(0);
+ set_has_bsize();
bsize_ = value;
}
// required fixed64 bavail = 2;
inline bool StatVFS::has_bavail() const {
- return _has_bit(1);
+ 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_bit(1);
+ clear_has_bavail();
}
inline ::google::protobuf::uint64 StatVFS::bavail() const {
return bavail_;
}
inline void StatVFS::set_bavail(::google::protobuf::uint64 value) {
- _set_bit(1);
+ 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_bit(2);
+ 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_bit(2);
+ clear_has_blocks();
}
inline ::google::protobuf::uint64 StatVFS::blocks() const {
return blocks_;
}
inline void StatVFS::set_blocks(::google::protobuf::uint64 value) {
- _set_bit(2);
+ set_has_blocks();
blocks_ = value;
}
// required string fsid = 4;
inline bool StatVFS::has_fsid() const {
- return _has_bit(3);
+ 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_ != &_default_fsid_) {
+ if (fsid_ != &::google::protobuf::internal::kEmptyString) {
fsid_->clear();
}
- _clear_bit(3);
+ clear_has_fsid();
}
inline const ::std::string& StatVFS::fsid() const {
return *fsid_;
}
inline void StatVFS::set_fsid(const ::std::string& value) {
- _set_bit(3);
- if (fsid_ == &_default_fsid_) {
+ 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_bit(3);
- if (fsid_ == &_default_fsid_) {
+ 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_bit(3);
- if (fsid_ == &_default_fsid_) {
+ 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_bit(3);
- if (fsid_ == &_default_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_bit(4);
+ 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_bit(4);
+ clear_has_namemax();
}
inline ::google::protobuf::uint32 StatVFS::namemax() const {
return namemax_;
}
inline void StatVFS::set_namemax(::google::protobuf::uint32 value) {
- _set_bit(4);
+ set_has_namemax();
namemax_ = value;
}
// required .xtreemfs.pbrpc.AccessControlPolicyType access_control_policy = 6;
inline bool StatVFS::has_access_control_policy() const {
- return _has_bit(5);
+ 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_bit(5);
+ clear_has_access_control_policy();
}
-inline xtreemfs::pbrpc::AccessControlPolicyType StatVFS::access_control_policy() const {
- return static_cast< xtreemfs::pbrpc::AccessControlPolicyType >(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) {
- GOOGLE_DCHECK(xtreemfs::pbrpc::AccessControlPolicyType_IsValid(value));
- _set_bit(5);
+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_bit(6);
+ 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_bit(6);
+ 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_bit(6);
+ 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_bit(7);
+ 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_bit(7);
+ clear_has_etag();
}
inline ::google::protobuf::uint64 StatVFS::etag() const {
return etag_;
}
inline void StatVFS::set_etag(::google::protobuf::uint64 value) {
- _set_bit(7);
+ set_has_etag();
etag_ = value;
}
// required fixed32 mode = 9;
inline bool StatVFS::has_mode() const {
- return _has_bit(8);
+ 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_bit(8);
+ clear_has_mode();
}
inline ::google::protobuf::uint32 StatVFS::mode() const {
return mode_;
}
inline void StatVFS::set_mode(::google::protobuf::uint32 value) {
- _set_bit(8);
+ set_has_mode();
mode_ = value;
}
// required string name = 10;
inline bool StatVFS::has_name() const {
- return _has_bit(9);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(9);
+ clear_has_name();
}
inline const ::std::string& StatVFS::name() const {
return *name_;
}
inline void StatVFS::set_name(const ::std::string& value) {
- _set_bit(9);
- if (name_ == &_default_name_) {
+ 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_bit(9);
- if (name_ == &_default_name_) {
+ 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_bit(9);
- if (name_ == &_default_name_) {
+ 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_bit(9);
- if (name_ == &_default_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_bit(10);
+ 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_ != &_default_owner_group_id_) {
+ if (owner_group_id_ != &::google::protobuf::internal::kEmptyString) {
owner_group_id_->clear();
}
- _clear_bit(10);
+ 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_bit(10);
- if (owner_group_id_ == &_default_owner_group_id_) {
+ 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_bit(10);
- if (owner_group_id_ == &_default_owner_group_id_) {
+ 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_bit(10);
- if (owner_group_id_ == &_default_owner_group_id_) {
+ 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_bit(10);
- if (owner_group_id_ == &_default_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_bit(11);
+ 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_ != &_default_owner_user_id_) {
+ if (owner_user_id_ != &::google::protobuf::internal::kEmptyString) {
owner_user_id_->clear();
}
- _clear_bit(11);
+ 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_bit(11);
- if (owner_user_id_ == &_default_owner_user_id_) {
+ 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_bit(11);
- if (owner_user_id_ == &_default_owner_user_id_) {
+ 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_bit(11);
- if (owner_user_id_ == &_default_owner_user_id_) {
+ 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_bit(11);
- if (owner_user_id_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -7455,53 +7637,101 @@ inline ::std::string* StatVFS::mutable_owner_user_id() {
// required .xtreemfs.pbrpc.Stat stbuf = 1;
inline bool fsetattrRequest::has_stbuf() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ 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_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ set_has_to_set();
to_set_ = value;
}
// required .xtreemfs.pbrpc.XCap cap = 3;
inline bool fsetattrRequest::has_cap() const {
- return _has_bit(2);
+ 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_bit(2);
+ 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_bit(2);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -7509,101 +7739,163 @@ inline ::xtreemfs::pbrpc::XCap* fsetattrRequest::mutable_cap() {
// required string volume_name = 1;
inline bool getattrRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
- _clear_bit(1);
+ clear_has_path();
}
inline const ::std::string& getattrRequest::path() const {
return *path_;
}
inline void getattrRequest::set_path(const ::std::string& value) {
- _set_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_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_bit(2);
+ 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_bit(2);
+ 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_bit(2);
+ set_has_known_etag();
known_etag_ = value;
}
@@ -7613,20 +7905,41 @@ inline void getattrRequest::set_known_etag(::google::protobuf::uint64 value) {
// optional .xtreemfs.pbrpc.Stat stbuf = 1;
inline bool getattrResponse::has_stbuf() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -7634,129 +7947,213 @@ inline ::xtreemfs::pbrpc::Stat* getattrResponse::mutable_stbuf() {
// required string volume_name = 1;
inline bool getxattrRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
- _clear_bit(1);
+ clear_has_path();
}
inline const ::std::string& getxattrRequest::path() const {
return *path_;
}
inline void getxattrRequest::set_path(const ::std::string& value) {
- _set_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_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_bit(2);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(2);
+ clear_has_name();
}
inline const ::std::string& getxattrRequest::name() const {
return *name_;
}
inline void getxattrRequest::set_name(const ::std::string& value) {
- _set_bit(2);
- if (name_ == &_default_name_) {
+ 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_bit(2);
- if (name_ == &_default_name_) {
+ 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_bit(2);
- if (name_ == &_default_name_) {
+ 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_bit(2);
- if (name_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -7764,86 +8161,142 @@ inline ::std::string* getxattrRequest::mutable_name() {
// required string value = 1;
inline bool getxattrResponse::has_value() const {
- return _has_bit(0);
+ 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_ != &_default_value_) {
+ if (value_ != &::google::protobuf::internal::kEmptyString) {
value_->clear();
}
- _clear_bit(0);
+ clear_has_value();
}
inline const ::std::string& getxattrResponse::value() const {
return *value_;
}
inline void getxattrResponse::set_value(const ::std::string& value) {
- _set_bit(0);
- if (value_ == &_default_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_bit(0);
- if (value_ == &_default_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_bit(0);
- if (value_ == &_default_value_) {
+ 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_bit(0);
- if (value_ == &_default_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 = 2;
-inline bool getxattrResponse::has_value_bytes() const {
- return _has_bit(1);
+// 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 void getxattrResponse::clear_value_bytes() {
- if (value_bytes_ != &_default_value_bytes_) {
- value_bytes_->clear();
+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;
}
- _clear_bit(1);
+ value_bytes_string_->assign(value);
}
-inline const ::std::string& getxattrResponse::value_bytes() const {
- return *value_bytes_;
+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(const ::std::string& value) {
- _set_bit(1);
- if (value_bytes_ == &_default_value_bytes_) {
- value_bytes_ = new ::std::string;
+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_->assign(value);
+ value_bytes_string_->assign(reinterpret_cast(value), size);
}
-inline void getxattrResponse::set_value_bytes(const char* value) {
- _set_bit(1);
- if (value_bytes_ == &_default_value_bytes_) {
- value_bytes_ = new ::std::string;
+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;
}
- value_bytes_->assign(value);
+ return value_bytes_string_;
}
-inline void getxattrResponse::set_value_bytes(const void* value, size_t size) {
- _set_bit(1);
- if (value_bytes_ == &_default_value_bytes_) {
- value_bytes_ = new ::std::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;
}
- value_bytes_->assign(reinterpret_cast(value), size);
}
-inline ::std::string* getxattrResponse::mutable_value_bytes() {
- _set_bit(1);
- if (value_bytes_ == &_default_value_bytes_) {
- value_bytes_ = new ::std::string;
+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);
}
- return value_bytes_;
}
// -------------------------------------------------------------------
@@ -7852,129 +8305,213 @@ inline ::std::string* getxattrResponse::mutable_value_bytes() {
// required string volume_name = 1;
inline bool linkRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_target_path_) {
+ if (target_path_ != &::google::protobuf::internal::kEmptyString) {
target_path_->clear();
}
- _clear_bit(1);
+ 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_bit(1);
- if (target_path_ == &_default_target_path_) {
+ 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_bit(1);
- if (target_path_ == &_default_target_path_) {
+ 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_bit(1);
- if (target_path_ == &_default_target_path_) {
+ 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_bit(1);
- if (target_path_ == &_default_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_bit(2);
+ 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_ != &_default_link_path_) {
+ if (link_path_ != &::google::protobuf::internal::kEmptyString) {
link_path_->clear();
}
- _clear_bit(2);
+ 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_bit(2);
- if (link_path_ == &_default_link_path_) {
+ 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_bit(2);
- if (link_path_ == &_default_link_path_) {
+ 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_bit(2);
- if (link_path_ == &_default_link_path_) {
+ 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_bit(2);
- if (link_path_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -7982,101 +8519,163 @@ inline ::std::string* linkRequest::mutable_link_path() {
// required string volume_name = 1;
inline bool listxattrRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
- _clear_bit(1);
+ clear_has_path();
}
inline const ::std::string& listxattrRequest::path() const {
return *path_;
}
inline void listxattrRequest::set_path(const ::std::string& value) {
- _set_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_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_bit(2);
+ 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_bit(2);
+ clear_has_names_only();
}
inline bool listxattrRequest::names_only() const {
return names_only_;
}
inline void listxattrRequest::set_names_only(bool value) {
- _set_bit(2);
+ set_has_names_only();
names_only_ = value;
}
@@ -8115,101 +8714,163 @@ listxattrResponse::mutable_xattrs() {
// required string volume_name = 1;
inline bool mkdirRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
- _clear_bit(1);
+ clear_has_path();
}
inline const ::std::string& mkdirRequest::path() const {
return *path_;
}
inline void mkdirRequest::set_path(const ::std::string& value) {
- _set_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_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_bit(2);
+ 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_bit(2);
+ clear_has_mode();
}
inline ::google::protobuf::uint32 mkdirRequest::mode() const {
return mode_;
}
inline void mkdirRequest::set_mode(::google::protobuf::uint32 value) {
- _set_bit(2);
+ set_has_mode();
mode_ = value;
}
@@ -8219,152 +8880,247 @@ inline void mkdirRequest::set_mode(::google::protobuf::uint32 value) {
// required string volume_name = 1;
inline bool openRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
- _clear_bit(1);
+ clear_has_path();
}
inline const ::std::string& openRequest::path() const {
return *path_;
}
inline void openRequest::set_path(const ::std::string& value) {
- _set_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_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_bit(2);
+ 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_bit(2);
+ clear_has_flags();
}
inline ::google::protobuf::uint32 openRequest::flags() const {
return flags_;
}
inline void openRequest::set_flags(::google::protobuf::uint32 value) {
- _set_bit(2);
+ set_has_flags();
flags_ = value;
}
// required fixed32 mode = 4;
inline bool openRequest::has_mode() const {
- return _has_bit(3);
+ 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_bit(3);
+ clear_has_mode();
}
inline ::google::protobuf::uint32 openRequest::mode() const {
return mode_;
}
inline void openRequest::set_mode(::google::protobuf::uint32 value) {
- _set_bit(3);
+ set_has_mode();
mode_ = value;
}
// required fixed32 attributes = 5;
inline bool openRequest::has_attributes() const {
- return _has_bit(4);
+ 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_bit(4);
+ clear_has_attributes();
}
inline ::google::protobuf::uint32 openRequest::attributes() const {
return attributes_;
}
inline void openRequest::set_attributes(::google::protobuf::uint32 value) {
- _set_bit(4);
+ set_has_attributes();
attributes_ = value;
}
// optional .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 6;
inline bool openRequest::has_coordinates() const {
- return _has_bit(5);
+ 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_bit(5);
+ 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_bit(5);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -8372,34 +9128,61 @@ inline ::xtreemfs::pbrpc::VivaldiCoordinates* openRequest::mutable_coordinates()
// required .xtreemfs.pbrpc.FileCredentials creds = 1;
inline bool openResponse::has_creds() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ 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_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ set_has_timestamp_s();
timestamp_s_ = value;
}
@@ -8409,149 +9192,229 @@ inline void openResponse::set_timestamp_s(::google::protobuf::uint32 value) {
// required string volume_name = 1;
inline bool readdirRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
- _clear_bit(1);
+ clear_has_path();
}
inline const ::std::string& readdirRequest::path() const {
return *path_;
}
inline void readdirRequest::set_path(const ::std::string& value) {
- _set_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_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_bit(2);
+ 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_bit(2);
+ 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_bit(2);
+ 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_bit(3);
+ 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_bit(3);
+ 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_bit(3);
+ 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_bit(4);
+ 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_bit(4);
+ clear_has_names_only();
}
inline bool readdirRequest::names_only() const {
return names_only_;
}
inline void readdirRequest::set_names_only(bool value) {
- _set_bit(4);
+ 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_bit(5);
+ 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_bit(5);
+ 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_bit(5);
+ set_has_seen_directory_entries_count();
seen_directory_entries_count_ = value;
}
@@ -8561,87 +9424,143 @@ inline void readdirRequest::set_seen_directory_entries_count(::google::protobuf:
// required string volume_name = 1;
inline bool readlinkRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
- _clear_bit(1);
+ clear_has_path();
}
inline const ::std::string& readlinkRequest::path() const {
return *path_;
}
inline void readlinkRequest::set_path(const ::std::string& value) {
- _set_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -8697,129 +9616,213 @@ readlinkResponse::mutable_link_target_path() {
// required string volume_name = 1;
inline bool removexattrRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_path_) {
+ if (path_ != &::google::protobuf::internal::kEmptyString) {
path_->clear();
}
- _clear_bit(1);
+ clear_has_path();
}
inline const ::std::string& removexattrRequest::path() const {
return *path_;
}
inline void removexattrRequest::set_path(const ::std::string& value) {
- _set_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_path_) {
+ 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_bit(1);
- if (path_ == &_default_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_bit(2);
+ 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_ != &_default_name_) {
+ if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
- _clear_bit(2);
+ clear_has_name();
}
inline const ::std::string& removexattrRequest::name() const {
return *name_;
}
inline void removexattrRequest::set_name(const ::std::string& value) {
- _set_bit(2);
- if (name_ == &_default_name_) {
+ 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_bit(2);
- if (name_ == &_default_name_) {
+ 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_bit(2);
- if (name_ == &_default_name_) {
+ 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_bit(2);
- if (name_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -8827,129 +9830,213 @@ inline ::std::string* removexattrRequest::mutable_name() {
// required string volume_name = 1;
inline bool renameRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_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_bit(1);
+ 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_ != &_default_source_path_) {
+ if (source_path_ != &::google::protobuf::internal::kEmptyString) {
source_path_->clear();
}
- _clear_bit(1);
+ 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_bit(1);
- if (source_path_ == &_default_source_path_) {
+ 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_bit(1);
- if (source_path_ == &_default_source_path_) {
+ 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_bit(1);
- if (source_path_ == &_default_source_path_) {
+ 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_bit(1);
- if (source_path_ == &_default_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_bit(2);
+ 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_ != &_default_target_path_) {
+ if (target_path_ != &::google::protobuf::internal::kEmptyString) {
target_path_->clear();
}
- _clear_bit(2);
+ 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_bit(2);
- if (target_path_ == &_default_target_path_) {
+ 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_bit(2);
- if (target_path_ == &_default_target_path_) {
+ 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_bit(2);
- if (target_path_ == &_default_target_path_) {
+ 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_bit(2);
- if (target_path_ == &_default_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);
+ }
+}
// -------------------------------------------------------------------
@@ -8957,36 +10044,63 @@ inline ::std::string* renameRequest::mutable_target_path() {
// required fixed32 timestamp_s = 1;
inline bool renameResponse::has_timestamp_s() const {
- return _has_bit(0);
+ 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_bit(0);
+ 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_bit(0);
+ set_has_timestamp_s();
timestamp_s_ = value;
}
// optional .xtreemfs.pbrpc.FileCredentials creds = 2;
inline bool renameResponse::has_creds() const {
- return _has_bit(1);
+ 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_bit(1);
+ 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_bit(1);
+ 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();
+ }
+}
// -------------------------------------------------------------------
@@ -8994,87 +10108,143 @@ inline ::xtreemfs::pbrpc::FileCredentials* renameResponse::mutable_creds() {
// required string volume_name = 1;
inline bool rmdirRequest::has_volume_name() const {
- return _has_bit(0);
+ 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_ != &_default_volume_name_) {
+ if (volume_name_ != &::google::protobuf::internal::kEmptyString) {
volume_name_->clear();
}
- _clear_bit(0);
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ 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_bit(0);
- if (volume_name_ == &_default_volume_name_) {
+ set_has_volume_name();
+ if (volume_name_ == &::google::protobuf::internal::kEmptyString) {
volume_name_ = new ::std::string;
}
volume_name_->assign(reinterpret_cast