for more details.
+ The XtreemOS project has been developed with the financial support of the
+ European Commission's IST program under contract #FP6-033576.
+
+ XtreemFS is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free
+ Software Foundation, either version 2 of the License, or (at your option)
+ any later version.
+
+ XtreemFS is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with XtreemFS. If not, see .
+*/
+/*
+ * AUTHORS: Björn Kolbeck (ZIB)
+ */
+
+package org.xtreemfs.common.clients.hadoop;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FSDataInputStream;
+import org.apache.hadoop.fs.FSDataOutputStream;
+import org.apache.hadoop.fs.FSInputStream;
+import org.apache.hadoop.fs.FileStatus;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.fs.permission.FsPermission;
+import org.apache.hadoop.util.Progressable;
+import org.xtreemfs.common.clients.Client;
+import org.xtreemfs.common.clients.File;
+import org.xtreemfs.common.clients.RandomAccessFile;
+import org.xtreemfs.common.clients.Volume;
+import org.xtreemfs.foundation.logging.Logging;
+import org.xtreemfs.foundation.logging.Logging.Category;
+import org.xtreemfs.interfaces.Constants;
+import org.xtreemfs.interfaces.DirectoryEntry;
+import org.xtreemfs.interfaces.Stat;
+import org.xtreemfs.interfaces.StringSet;
+import org.xtreemfs.interfaces.UserCredentials;
+
+/**
+ * A XtreemFS driver for hadoop
+ * URI format: xtreemfs://dirAddr:port/path...
+ * required configuration:
+ *
+ *
+ * xtreemfs.volumeName
+ * volumeName
+ * Name of the volume to use within XtreemFS.
+ *
+ *
+ *
+ * fs.xtreemfs.impl
+ * org.xtreemfs.common.clients.hadoop.XtreemFSFileSystem
+ * The FileSystem for xtreemfs: uris.
+ *
+ *
+ * @author bjko
+ */
+public class XtreemFSFileSystem extends FileSystem {
+
+ private Client xtreemfsClient;
+
+ private Volume volume;
+
+ private URI fsURI;
+
+ private Path workingDirectory;
+
+
+ @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",false)) {
+ logLevel = Logging.LEVEL_DEBUG;
+ }
+
+ String volumeName = conf.get("xtreemfs.volumeName");
+ if (volumeName == null)
+ throw new IOException("You have to specify a volume name at the" +
+ " core-site.xml! (xtreemfs.volumeName)");
+
+ Logging.start(logLevel, Category.all);
+ Logging.logMessage(Logging.LEVEL_DEBUG, this,"init : "+uri);
+ InetSocketAddress dir = new InetSocketAddress(uri.getHost(), uri.getPort());
+ xtreemfsClient = new Client(new InetSocketAddress[]{dir}, 30*1000, 15*60*1000, null);
+ try {
+ xtreemfsClient.start();
+ } catch (Exception ex) {
+ throw new IOException("cannot start XtreemFS client", ex);
+ }
+
+ UserCredentials uc = null;
+ if ( (conf.get("xtreemfs.client.userid") != null)
+ && (conf.get("xtreemfs.client.groupid") != null) ){
+ StringSet grps = new StringSet();
+ grps.add(conf.get("xtreemfs.client.groupid"));
+ uc = new UserCredentials(conf.get("xtreemfs.client.userid"), grps, "");
+ }
+ if (uc == null) {
+ //try to guess from env
+ if (System.getenv("USER") != null) {
+ StringSet grps = new StringSet();
+ grps.add("users");
+ uc = new UserCredentials(System.getProperty("user.name"), grps, "");
+ }
+ }
+
+ fsURI = uri;
+ workingDirectory = getHomeDirectory();
+ volume = xtreemfsClient.getVolume(volumeName, uc);
+ Logging.logMessage(Logging.LEVEL_DEBUG, this,"file system init complete: "+uri.getUserInfo());
+ }
+
+ @Override
+ public URI getUri() {
+ return fsURI;
+ }
+
+ @Override
+ public FSDataInputStream open(Path file, final int buffSize) throws IOException {
+ final String path = file.toUri().getPath();
+ File f = volume.getFile(path);
+ final RandomAccessFile raf = f.open("r",0);
+
+ return new FSDataInputStream(new FSInputStream() {
+
+ @Override
+ public void seek(long pos) throws IOException {
+ raf.seek(pos);
+ }
+
+ @Override
+ public long getPos() throws IOException {
+ return raf.getFilePointer();
+ }
+
+ @Override
+ public boolean seekToNewSource(long arg0) throws IOException {
+ return false;
+ }
+
+ @Override
+ public int read() throws IOException {
+ byte[] b = new byte[1];
+ int numRead = raf.read(b,0,1);
+ if (numRead == 0)
+ return -1;
+ return b[0];
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ int nbRead = raf.read(b,off,len);
+ if ((nbRead == 0) && (len > 0))
+ return -1;
+ else
+ return nbRead;
+ }
+
+ @Override
+ public int read(byte[] b) throws IOException {
+ return raf.read(b,0,b.length);
+ }
+ });
+
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public FSDataOutputStream create(Path file, FsPermission permissions,
+ boolean overwrite, int bufferSize, short replication, long blockSize, Progressable prog) throws IOException {
+ final String path = file.toUri().getPath();
+ File f = volume.getFile(path);
+ String openMode = "rw";
+ if (overwrite)
+ openMode += "t";
+
+ final RandomAccessFile raf = f.open(openMode,permissions.toShort());
+
+ return new FSDataOutputStream(new OutputStream() {
+
+ @Override
+ public void write(byte[] b, int off, int len) throws IOException {
+ raf.write(b,off,len);
+ }
+
+ @Override
+ public void write(byte[] b) throws IOException {
+ raf.write(b,0,b.length);
+ }
+
+ @Override
+ public void write(int b) throws IOException {
+ raf.write(new byte[]{(byte)b},0,1);
+ }
+
+ @Override
+ public void close() throws IOException {
+ raf.close();
+ }
+ });
+ }
+
+ @Override
+ public FSDataOutputStream append(Path arg0, int arg1, Progressable arg2) throws IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rename(Path src, Path dest) throws IOException {
+ final String srcPath = src.toUri().getPath();
+ final String destPath = dest.toUri().getPath();
+
+ File srcFile = volume.getFile(srcPath);
+ File destFile = volume.getFile(destPath);
+ srcFile.renameTo(destFile);
+ return true;
+ }
+
+ @Override
+ public boolean delete(Path file) throws IOException {
+ return delete(file,false);
+ }
+
+ @Override
+ public boolean delete(Path file, boolean recursive) throws IOException {
+ try {
+ final String path = file.toUri().getPath();
+ return delete(path);
+ } catch (FileNotFoundException f) {
+ Logging.logMessage(Logging.LEVEL_WARN, this, "'%s' could not be " +
+ "deleted, because it is not available.", file.toString());
+ return false;
+ }
+ }
+
+ protected boolean delete(String path) throws IOException {
+ Logging.logMessage(Logging.LEVEL_DEBUG, this,"getattr: "+path);
+ File f = volume.getFile(path);
+ if (f.isDirectory()) {
+
+ //delete all entries
+ String[] entries = volume.list(path);
+ for (String e : entries) {
+ if (delete(path+"/"+e) == false)
+ return false;
+ }
+ f.delete();
+
+ return true;
+ } else {
+ //file
+ f.delete();
+ return true;
+ }
+ }
+
+ @Override
+ public FileStatus[] listStatus(Path hdPath) throws IOException {
+ if (hdPath == null) return null;
+
+ final String path = hdPath.toUri().getPath();
+ Logging.logMessage(Logging.LEVEL_DEBUG, this,"ls: "+path);
+ DirectoryEntry[] list = volume.listEntries(path);
+ if (list == null) return null;
+
+ FileStatus[] fslist = new FileStatus[list.length];
+ for (int i = 0; i < list.length; i++) {
+ final DirectoryEntry e = list[i];
+ final Stat s = e.getStbuf().get(0);
+ final boolean isDir = (s.getMode() & Constants.SYSTEM_V_FCNTL_H_S_IFDIR) > 0;
+ fslist[i] = new FileStatus(s.getSize(), isDir , 1, 1,(long) (s.getMtime_ns() / 1e6),
+ (long) (s.getAtime_ns() / 1e6), new FsPermission((short)s.getMode()),
+ s.getUser_id(), s.getGroup_id(), new Path(hdPath,e.getName()));
+ }
+ return fslist;
+ }
+
+ @Override
+ public void setWorkingDirectory(Path arg0) {
+ this.workingDirectory = arg0;
+ }
+
+ @Override
+ public Path getWorkingDirectory() {
+ return this.workingDirectory;
+ }
+
+ @Override
+ public boolean mkdirs(Path path, FsPermission perm) throws IOException {
+ final String pathStr = path.toUri().getPath();
+ final String[] dirs = pathStr.split("/");
+ String tmpPath = "";
+ for (String dir : dirs) {
+ tmpPath += dir+"/";
+ File d = volume.getFile(tmpPath);
+ if (d.exists()) {
+ if (!d.isDirectory())
+ return false;
+ } else {
+ d.mkdir((int)perm.toShort());
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public FileStatus getFileStatus(Path file) throws IOException {
+ final String path = file.toUri().getPath();
+ Logging.logMessage(Logging.LEVEL_DEBUG, this,"getattr: "+path);
+ File f = volume.getFile(path);
+ Stat s = f.stat();
+ final boolean isDir = (s.getMode() & Constants.SYSTEM_V_FCNTL_H_S_IFDIR) > 0;
+ return new FileStatus(s.getSize(), isDir , 1, 1,(long) (s.getMtime_ns() / 1e6),
+ (long) (s.getAtime_ns() / 1e6), new FsPermission((short)s.getMode()),
+ s.getUser_id(), s.getGroup_id(), file);
+ }
+
+ public void close() {
+ xtreemfsClient.stop();
+ }
+}
diff --git a/contrib/server-repl-plugin/LICENSE b/contrib/server-repl-plugin/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2f354973f2818748843772adc5b1d0c9e88d1191
--- /dev/null
+++ b/contrib/server-repl-plugin/LICENSE
@@ -0,0 +1,32 @@
+Copyright (c) 2008-2011, Jan Stender, Bjoern Kolbeck, Mikael Hoegqvist,
+ Felix Hupfeld, Felix Langner, Zuse Institute Berlin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials
+ provided with the distribution.
+ * Neither the name of the Zuse Institute Berlin nor the
+ names of its contributors may be used to endorse or promote
+ products derived from this software without specific prior
+ written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/contrib/server-repl-plugin/README b/contrib/server-repl-plugin/README
new file mode 100644
index 0000000000000000000000000000000000000000..c364af4131bed0c855f8e95dddc5ca52886761c9
--- /dev/null
+++ b/contrib/server-repl-plugin/README
@@ -0,0 +1,3 @@
+For further details on how to use the BabuDB replication plug-in, please refer to the BabuDB Wiki:
+
+http://code.google.com/p/babudb/wiki/UsageReplicationForJava
\ No newline at end of file
diff --git a/contrib/server-repl-plugin/config/dir1.properties b/contrib/server-repl-plugin/config/dir1.properties
new file mode 100644
index 0000000000000000000000000000000000000000..14d9b27a1249f36a665eb151791d59f485a2c8ce
--- /dev/null
+++ b/contrib/server-repl-plugin/config/dir1.properties
@@ -0,0 +1,60 @@
+#####################################################################
+# BabuDB replication plugin configuration #
+#####################################################################
+
+plugin.jar = contrib/server-repl-plugin/replication.jar
+
+# paths to libraries this plugin depends on
+babudb.repl.dependency.0 = contrib/server-repl-plugin/lib/PBRPC.jar
+babudb.repl.dependency.1 = contrib/server-repl-plugin/lib/Flease.jar
+babudb.repl.dependency.2 = contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar
+
+# DB backup directory - needed for the initial loading of the BabuDB from the
+# master in replication context
+babudb.repl.backupDir = /tmp/xtreemfs-test/dir/backup
+
+# number of servers that at least have to be up to date
+babudb.repl.sync.n = 2
+
+# choose here one of the predefined or a user implemented policy for handling
+# database requests:
+#
+# MasterOnly - will redirect any kind of request to the master.
+# NoRestriction - will allow any kind of request to be performed at the local
+# BabuDB instance.
+#
+# default setting is MasterOnly.
+#babudb.repl.policy = MasterOnly
+
+# it is possible to set the local address and port of this server explicitly. if not it will be
+# chosen from the list of participants added right hereafter (default).
+babudb.repl.localhost = localhost
+babudb.repl.localport = 35677
+
+# participants of the replication including the local address (may be missing, if localhost was
+# defined explicitly)
+babudb.repl.participant.0 = localhost
+babudb.repl.participant.0.port = 35677
+babudb.repl.participant.1 = localhost
+babudb.repl.participant.1.port = 35676
+
+# local time renew in milliseconds
+#babudb.localTimeRenew = 3000
+
+# specify whether SSL is required
+#babudb.ssl.enabled = false
+
+# server credentials for SSL handshakes
+#babudb.ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12
+#babudb.ssl.service_creds.pw = xtreemfs
+#babudb.ssl.service_creds.container = pkcs12
+
+# trusted certificates for SSL handshakes
+#babudb.ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/xosrootca.jks
+#babudb.ssl.trusted_certs.pw = xtreemfs
+#babudb.ssl.trusted_certs.container = jks
+
+#babudb.ssl.authenticationWithoutEncryption = false
+
+# chunk size, for initial load of file chunks
+#babudb.repl.chunkSize = 5242880
\ No newline at end of file
diff --git a/contrib/server-repl-plugin/config/dir2.properties b/contrib/server-repl-plugin/config/dir2.properties
new file mode 100644
index 0000000000000000000000000000000000000000..e06734cc39a07aafc0e68a758cd960d6e463b856
--- /dev/null
+++ b/contrib/server-repl-plugin/config/dir2.properties
@@ -0,0 +1,60 @@
+#####################################################################
+# BabuDB replication plugin configuration #
+#####################################################################
+
+plugin.jar = contrib/server-repl-plugin/replication.jar
+
+# paths to libraries this plugin depends on
+babudb.repl.dependency.0 = contrib/server-repl-plugin/lib/PBRPC.jar
+babudb.repl.dependency.1 = contrib/server-repl-plugin/lib/Flease.jar
+babudb.repl.dependency.2 = contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar
+
+# DB backup directory - needed for the initial loading of the BabuDB from the
+# master in replication context
+babudb.repl.backupDir = /tmp/xtreemfs-test/dir2/backup
+
+# number of servers that at least have to be up to date
+babudb.repl.sync.n = 2
+
+# choose here one of the predefined or a user implemented policy for handling
+# database requests:
+#
+# MasterOnly - will redirect any kind of request to the master.
+# NoRestriction - will allow any kind of request to be performed at the local
+# BabuDB instance.
+#
+# default setting is MasterOnly.
+#babudb.repl.policy = MasterOnly
+
+# it is possible to set the local address and port of this server explicitly. if not it will be
+# chosen from the list of participants added right hereafter (default).
+babudb.repl.localhost = localhost
+babudb.repl.localport = 35676
+
+# participants of the replication including the local address (may be missing, if localhost was
+# defined explicitly)
+babudb.repl.participant.0 = localhost
+babudb.repl.participant.0.port = 35677
+babudb.repl.participant.1 = localhost
+babudb.repl.participant.1.port = 35676
+
+# local time renew in milliseconds
+#babudb.localTimeRenew = 3000
+
+# specify whether SSL is required
+#babudb.ssl.enabled = false
+
+# server credentials for SSL handshakes
+#babudb.ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12
+#babudb.ssl.service_creds.pw = xtreemfs
+#babudb.ssl.service_creds.container = pkcs12
+
+# trusted certificates for SSL handshakes
+#babudb.ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/xosrootca.jks
+#babudb.ssl.trusted_certs.pw = xtreemfs
+#babudb.ssl.trusted_certs.container = jks
+
+#babudb.ssl.authenticationWithoutEncryption = false
+
+# chunk size, for initial load of file chunks
+#babudb.repl.chunkSize = 5242880
\ No newline at end of file
diff --git a/contrib/server-repl-plugin/config/mrc1.properties b/contrib/server-repl-plugin/config/mrc1.properties
new file mode 100644
index 0000000000000000000000000000000000000000..fdafe97f65cd7e27315e940cbe66ed354f9da296
--- /dev/null
+++ b/contrib/server-repl-plugin/config/mrc1.properties
@@ -0,0 +1,60 @@
+#####################################################################
+# BabuDB replication plugin configuration #
+#####################################################################
+
+plugin.jar = contrib/server-repl-plugin/replication.jar
+
+# paths to libraries this plugin depends on
+babudb.repl.dependency.0 = contrib/server-repl-plugin/lib/PBRPC.jar
+babudb.repl.dependency.1 = contrib/server-repl-plugin/lib/Flease.jar
+babudb.repl.dependency.2 = contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar
+
+# DB backup directory - needed for the initial loading of the BabuDB from the
+# master in replication context
+babudb.repl.backupDir = /tmp/babuDB-backup-mrc1/
+
+# number of servers that at least have to be up to date
+babudb.repl.sync.n = 2
+
+# choose here one of the predefined or a user implemented policy for handling
+# database requests:
+#
+# MasterOnly - will redirect any kind of request to the master.
+# NoRestriction - will allow any kind of request to be performed at the local
+# BabuDB instance.
+#
+# default setting is MasterOnly.
+#babudb.repl.policy = NoRestriction
+
+# it is possible to set the local address and port of this server explicitly. if not it will be
+# chosen from the list of participants added right hereafter (default).
+babudb.repl.localhost = localhost
+babudb.repl.localport = 35667
+
+# participants of the replication including the local address (may be missing, if localhost was
+# defined explicitly)
+babudb.repl.participant.0 = localhost
+babudb.repl.participant.0.port = 35667
+babudb.repl.participant.1 = localhost
+babudb.repl.participant.1.port = 35666
+
+# local time renew in milliseconds
+#babudb.localTimeRenew = 3000
+
+# specify whether SSL is required
+#babudb.ssl.enabled = false
+
+# server credentials for SSL handshakes
+#babudb.ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12
+#babudb.ssl.service_creds.pw = xtreemfs
+#babudb.ssl.service_creds.container = pkcs12
+
+# trusted certificates for SSL handshakes
+#babudb.ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/xosrootca.jks
+#babudb.ssl.trusted_certs.pw = xtreemfs
+#babudb.ssl.trusted_certs.container = jks
+
+#babudb.ssl.authenticationWithoutEncryption = false
+
+# chunk size, for initial load of file chunks
+#babudb.repl.chunkSize = 5242880
\ No newline at end of file
diff --git a/contrib/server-repl-plugin/config/mrc2.properties b/contrib/server-repl-plugin/config/mrc2.properties
new file mode 100644
index 0000000000000000000000000000000000000000..a419035e990f8a24367c27b661cc25a534d25dd7
--- /dev/null
+++ b/contrib/server-repl-plugin/config/mrc2.properties
@@ -0,0 +1,60 @@
+#####################################################################
+# BabuDB replication plugin configuration #
+#####################################################################
+
+plugin.jar = contrib/server-repl-plugin/replication.jar
+
+# paths to libraries this plugin depends on
+babudb.repl.dependency.0 = contrib/server-repl-plugin/lib/PBRPC.jar
+babudb.repl.dependency.1 = contrib/server-repl-plugin/lib/Flease.jar
+babudb.repl.dependency.2 = contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar
+
+# DB backup directory - needed for the initial loading of the BabuDB from the
+# master in replication context
+babudb.repl.backupDir = /tmp/babuDB-backup-mrc2/
+
+# number of servers that at least have to be up to date
+babudb.repl.sync.n = 2
+
+# choose here one of the predefined or a user implemented policy for handling
+# database requests:
+#
+# MasterOnly - will redirect any kind of request to the master.
+# NoRestriction - will allow any kind of request to be performed at the local
+# BabuDB instance.
+#
+# default setting is MasterOnly.
+#babudb.repl.policy = NoRestriction
+
+# it is possible to set the local address and port of this server explicitly. if not it will be
+# chosen from the list of participants added right hereafter (default).
+babudb.repl.localhost = localhost
+babudb.repl.localport = 35666
+
+# participants of the replication including the local address (may be missing, if localhost was
+# defined explicitly)
+babudb.repl.participant.0 = localhost
+babudb.repl.participant.0.port = 35667
+babudb.repl.participant.1 = localhost
+babudb.repl.participant.1.port = 35666
+
+# local time renew in milliseconds
+#babudb.localTimeRenew = 3000
+
+# specify whether SSL is required
+#babudb.ssl.enabled = false
+
+# server credentials for SSL handshakes
+#babudb.ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12
+#babudb.ssl.service_creds.pw = xtreemfs
+#babudb.ssl.service_creds.container = pkcs12
+
+# trusted certificates for SSL handshakes
+#babudb.ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/xosrootca.jks
+#babudb.ssl.trusted_certs.pw = xtreemfs
+#babudb.ssl.trusted_certs.container = jks
+
+#babudb.ssl.authenticationWithoutEncryption = false
+
+# chunk size, for initial load of file chunks
+#babudb.repl.chunkSize = 5242880
\ No newline at end of file
diff --git a/contrib/server-repl-plugin/lib/Flease.jar b/contrib/server-repl-plugin/lib/Flease.jar
new file mode 100644
index 0000000000000000000000000000000000000000..aa75be12a40a6accbe739d6802def7e8ab3bbe9f
Binary files /dev/null and b/contrib/server-repl-plugin/lib/Flease.jar differ
diff --git a/contrib/server-repl-plugin/lib/PBRPC.jar b/contrib/server-repl-plugin/lib/PBRPC.jar
new file mode 100644
index 0000000000000000000000000000000000000000..9300fc0c825999e1296246cd0b8fd6b809a3eeb0
Binary files /dev/null and b/contrib/server-repl-plugin/lib/PBRPC.jar differ
diff --git a/contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar b/contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar
new file mode 100644
index 0000000000000000000000000000000000000000..3c87f156dfed4412778a5cddee79db26593fea88
Binary files /dev/null and b/contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar differ
diff --git a/contrib/server-repl-plugin/replication.jar b/contrib/server-repl-plugin/replication.jar
new file mode 100644
index 0000000000000000000000000000000000000000..c49d05eb1cfbe35cbeaac86523dffa5a8ceb32a7
Binary files /dev/null and b/contrib/server-repl-plugin/replication.jar differ
diff --git a/cpp/.cproject b/cpp/.cproject
new file mode 100644
index 0000000000000000000000000000000000000000..73809f07d0955a96e6f2e95c784de2a761ed8bf5
--- /dev/null
+++ b/cpp/.cproject
@@ -0,0 +1,78 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/cpp/.project b/cpp/.project
new file mode 100644
index 0000000000000000000000000000000000000000..9f27624e8e35f86753058e5eab18fed610766f4a
--- /dev/null
+++ b/cpp/.project
@@ -0,0 +1,83 @@
+
+
+ mberlin-libxtreemfs_separation
+
+
+
+
+
+ org.eclipse.cdt.managedbuilder.core.genmakebuilder
+ clean,full,incremental,
+
+
+ ?name?
+
+
+
+ org.eclipse.cdt.make.core.append_environment
+ true
+
+
+ org.eclipse.cdt.make.core.autoBuildTarget
+ all
+
+
+ org.eclipse.cdt.make.core.buildArguments
+
+
+
+ org.eclipse.cdt.make.core.buildCommand
+ make
+
+
+ org.eclipse.cdt.make.core.buildLocation
+ ${workspace_loc:/pb_experimental_cpp/build}
+
+
+ org.eclipse.cdt.make.core.cleanBuildTarget
+ clean
+
+
+ org.eclipse.cdt.make.core.contents
+ org.eclipse.cdt.make.core.activeConfigSettings
+
+
+ org.eclipse.cdt.make.core.enableAutoBuild
+ false
+
+
+ org.eclipse.cdt.make.core.enableCleanBuild
+ true
+
+
+ org.eclipse.cdt.make.core.enableFullBuild
+ true
+
+
+ org.eclipse.cdt.make.core.fullBuildTarget
+ all
+
+
+ org.eclipse.cdt.make.core.stopOnError
+ true
+
+
+ org.eclipse.cdt.make.core.useDefaultBuildCmd
+ true
+
+
+
+
+ org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder
+ full,incremental,
+
+
+
+
+
+ org.eclipse.cdt.core.cnature
+ org.eclipse.cdt.core.ccnature
+ org.eclipse.cdt.managedbuilder.core.managedBuildNature
+ org.eclipse.cdt.managedbuilder.core.ScannerConfigNature
+
+
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..97eb5bed223ba2e7c7234e3531510c00c05d6481
--- /dev/null
+++ b/cpp/CMakeLists.txt
@@ -0,0 +1,116 @@
+cmake_minimum_required(VERSION 2.6)
+PROJECT(cpp CXX)
+# enable_testing() will provide a target "test".
+enable_testing()
+option(build_thirdparty "Executes ./configure and make commands on required thirdparty libraries" ON)
+
+#SET (CMAKE_VERBOSE_MAKEFILE true)
+
+ADD_DEFINITIONS(-D_FILE_OFFSET_BITS=64)
+
+##########################################
+
+CMAKE_POLICY(SET CMP0003 OLD)
+ADD_LIBRARY(protobuf STATIC IMPORTED)
+
+# build the protobuf library
+IF(UNIX)
+ IF (build_thirdparty)
+ MESSAGE(STATUS "building protobuf")
+ EXECUTE_PROCESS(COMMAND ./configure WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/thirdparty/protobuf-2.3.0)
+ EXECUTE_PROCESS(COMMAND make WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/thirdparty/protobuf-2.3.0)
+ ENDIF(build_thirdparty)
+
+ SET_PROPERTY(TARGET protobuf PROPERTY IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/thirdparty/protobuf-2.3.0/src/.libs/libprotobuf.a)
+ENDIF(UNIX)
+# TODO: add ELSEIF for WIN32/WIN64
+
+include_directories(${CMAKE_SOURCE_DIR}/thirdparty/protobuf-2.3.0/src)
+include_directories(${CMAKE_SOURCE_DIR}/thirdparty/protobuf-2.3.0)
+
+##########################################
+MESSAGE(STATUS "Configuring XtreemFS client (libxtreemfs, FuseAdapter(mount.xtreemfs) and Volume Tools ({mkfs,rmfs,lsfs}.xtreemfs).")
+
+SET(BOOST_LIBRARYDIR "/usr/lib64")
+FIND_PACKAGE(Boost COMPONENTS system thread program_options regex REQUIRED)
+
+INCLUDE_DIRECTORIES(include generated)
+
+file(GLOB_RECURSE SRCS_RPC src/rpc/*.cpp)
+file(GLOB_RECURSE SRCS_UTIL src/util/*.cpp)
+file(GLOB_RECURSE SRCS_GENERATED generated/*.cc)
+file(GLOB_RECURSE SRCS_XTREEMFS src/libxtreemfs/*.cpp)
+add_library(xtreemfs ${SRCS_RPC} ${SRCS_UTIL} ${SRCS_GENERATED} ${SRCS_XTREEMFS})
+
+set(CMAKE_CXX_FLAGS "-Wall -Wno-unused-function -Wno-sign-compare")
+
+ADD_EXECUTABLE(example_libxtreemfs src/example_libxtreemfs/example_libxtreemfs.cpp)
+TARGET_LINK_LIBRARIES(example_libxtreemfs xtreemfs protobuf crypto pthread ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ssl)
+
+file(GLOB_RECURSE SRCS_FUSE_ADAPTER src/fuse/*.cpp)
+file(GLOB_RECURSE SRCS_XTFS_UTIL src/xtfsutil/xtfsutil_server.cpp)
+file(GLOB_RECURSE SRCS_JSONCPP src/json/*.cpp)
+ADD_EXECUTABLE(mount.xtreemfs ${SRCS_FUSE_ADAPTER} ${SRCS_XTFS_UTIL} ${SRCS_JSONCPP})
+TARGET_LINK_LIBRARIES(mount.xtreemfs xtreemfs protobuf crypto pthread ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ssl fuse)
+
+file(GLOB_RECURSE SRCS_MKFS src/mkfs.xtreemfs/*.cpp)
+ADD_EXECUTABLE(mkfs.xtreemfs ${SRCS_MKFS})
+TARGET_LINK_LIBRARIES(mkfs.xtreemfs xtreemfs protobuf crypto pthread ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ssl fuse)
+
+file(GLOB_RECURSE SRCS_RMFS src/rmfs.xtreemfs/*.cpp)
+ADD_EXECUTABLE(rmfs.xtreemfs ${SRCS_RMFS})
+TARGET_LINK_LIBRARIES(rmfs.xtreemfs xtreemfs protobuf crypto pthread ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ssl fuse)
+
+file(GLOB_RECURSE SRCS_LSFS src/lsfs.xtreemfs/*.cpp)
+ADD_EXECUTABLE(lsfs.xtreemfs ${SRCS_LSFS})
+TARGET_LINK_LIBRARIES(lsfs.xtreemfs xtreemfs protobuf crypto pthread ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ssl fuse)
+
+ADD_EXECUTABLE(xtfsutil src/xtfsutil/xtfsutil.cpp ${SRCS_JSONCPP})
+TARGET_LINK_LIBRARIES(xtfsutil ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ${Boost_REGEX_LIBRARY} attr)
+
+##########################################
+
+CMAKE_POLICY(SET CMP0003 OLD)
+ADD_LIBRARY(gtest STATIC IMPORTED)
+ADD_LIBRARY(gtest_main STATIC IMPORTED)
+
+# build the gtest library
+IF(UNIX)
+ IF (build_thirdparty)
+ MESSAGE(STATUS "building gtest")
+ EXECUTE_PROCESS(COMMAND ./configure WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/thirdparty/gtest-1.5.0)
+ EXECUTE_PROCESS(COMMAND make WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/thirdparty/gtest-1.5.0)
+ ENDIF(build_thirdparty)
+
+ SET_PROPERTY(TARGET gtest PROPERTY IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/thirdparty/gtest-1.5.0/lib/.libs/libgtest.a)
+ SET_PROPERTY(TARGET gtest_main PROPERTY IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/thirdparty/gtest-1.5.0/lib/.libs/libgtest_main.a)
+ENDIF(UNIX)
+# TODO: add ELSEIF for WIN32/WIN64
+
+include_directories(${CMAKE_SOURCE_DIR}/thirdparty/gtest-1.5.0/include)
+
+##########################################
+MESSAGE(STATUS "Configuring libxtreemfs unittests.")
+
+SET(BOOST_LIBRARYDIR "/usr/lib64")
+FIND_PACKAGE(Boost COMPONENTS system thread program_options REQUIRED)
+
+INCLUDE_DIRECTORIES(include generated)
+
+set(CMAKE_CXX_FLAGS "-Wall -Wno-unused-function -Wno-sign-compare")
+
+file(GLOB TESTS test/*)
+foreach (testdir ${TESTS})
+ if(IS_DIRECTORY ${testdir})
+ get_filename_component(testname ${testdir} NAME)
+ set(testname "test_${testname}")
+ file(GLOB_RECURSE SRCS_TESTS ${testdir}/*.cpp)
+ if (SRCS_TESTS)
+ MESSAGE(STATUS "\tConfiguring test: ${testname}.")
+ add_executable(${testname} ${SRCS_TESTS})
+ TARGET_LINK_LIBRARIES(${testname} gtest_main gtest xtreemfs protobuf crypto pthread ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY} ssl)
+ ADD_TEST(${testname} ${testname})
+ endif()
+ #endif(if(IS_DIRECTORY $entry)
+ endif()
+endforeach()
diff --git a/cpp/Doxyfile b/cpp/Doxyfile
new file mode 100644
index 0000000000000000000000000000000000000000..07fd28c7654ef9e4c19f485e2aba293d5c05c70f
--- /dev/null
+++ b/cpp/Doxyfile
@@ -0,0 +1,1623 @@
+# Doxyfile 1.7.1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+# TAG = value [value, ...]
+# For lists items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
+# by quotes) that should identify the project.
+
+PROJECT_NAME = XtreemFS-Client
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY =
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF =
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful is your file systems
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE = 8
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given extension.
+# Doxygen has a built-in mapping, but you can override or extend it using this
+# tag. The format is ext=language, where ext is a file extension, and language
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+
+EXTENSION_MAPPING =
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen to replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penality.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will rougly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespace are hidden.
+
+EXTRACT_ANON_NSPACES = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or define consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and defines in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES = YES
+
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page. This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command , where is the value of
+# the FILE_VERSION_FILTER tag, and is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. The create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR = YES
+
+# This WARN_NO_PARAMDOC option can be abled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT = src \
+ include \
+ test
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
+
+FILE_PATTERNS =
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE =
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix filesystem feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS =
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command , where
+# is the value of the INPUT_FILTER tag, and is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output. If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
+# is applied to all files.
+
+FILTER_PATTERNS =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code. Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header.
+
+HTML_HEADER =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the stylesheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP = YES
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+#
+# Qt Help Project / Custom Filters.
+
+QHP_CUST_FILTER_ATTRS =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+#
+# Qt Help Project / Filter Attributes.
+
+QHP_SECT_FILTER_ATTRS =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+# will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it.
+
+DISABLE_INDEX = NO
+
+# This tag can be used to set the number of enum values (range [1..20])
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW = NO
+
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+
+USE_INLINE_TREES = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT = YES
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvances is that it is more difficult to setup
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, a4wide, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader. This is useful
+# if you want to understand what is going on. On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all function-like macros that are alone
+# on a line, have an all uppercase name, and do not end with a semicolon. Such
+# function macros are typically used for boiler-plate code, and will confuse
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option is superseded by the HAVE_DOT option below. This is only a
+# fallback. It is recommended to install and use dot, since it yields more
+# powerful graphs.
+
+CLASS_DIAGRAMS = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS = 0
+
+# By default doxygen will write a font called FreeSans.ttf to the output
+# directory and reference it in all dot files that doxygen generates. This
+# font does not include all possible unicode characters however, so when you need
+# these (or just want a differently looking font) you can specify the font name
+# using DOT_FONTNAME. You need need to make sure dot is able to find the font,
+# which can be done by putting it in a standard location or by setting the
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
+# containing the font.
+
+DOT_FONTNAME = FreeSans.ttf
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE = 10
+
+# By default doxygen will tell dot to use the output directory to look for the
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a
+# different font using DOT_FONTNAME you can set the path where dot
+# can find it using this tag.
+
+DOT_FONTPATH =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are png, jpg, or gif
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS = YES
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP = YES
diff --git a/cpp/Makefile b/cpp/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..0e61a62dc993c99663d81f94336ef2c6d627ccef
--- /dev/null
+++ b/cpp/Makefile
@@ -0,0 +1,740 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 2.8
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canoncical targets will work.
+.SUFFIXES:
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# The program to use to edit the cache.
+CMAKE_EDIT_COMMAND = /usr/bin/ccmake
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/bjko/work/pb_experimental/cpp
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/bjko/work/pb_experimental/cpp
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+ @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
+ /usr/bin/ccmake -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+ @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
+ /usr/bin/cmake -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# The main all target
+all: cmake_check_build_system
+ $(CMAKE_COMMAND) -E cmake_progress_start /home/bjko/work/pb_experimental/cpp/CMakeFiles /home/bjko/work/pb_experimental/cpp/CMakeFiles/progress.marks
+ $(MAKE) -f CMakeFiles/Makefile2 all
+ $(CMAKE_COMMAND) -E cmake_progress_start /home/bjko/work/pb_experimental/cpp/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+ $(MAKE) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+ $(MAKE) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+ $(MAKE) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+ $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+#=============================================================================
+# Target rules for targets named fusetest
+
+# Build rule for target.
+fusetest: cmake_check_build_system
+ $(MAKE) -f CMakeFiles/Makefile2 fusetest
+.PHONY : fusetest
+
+# fast build rule for target.
+fusetest/fast:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/build
+.PHONY : fusetest/fast
+
+#=============================================================================
+# Target rules for targets named main
+
+# Build rule for target.
+main: cmake_check_build_system
+ $(MAKE) -f CMakeFiles/Makefile2 main
+.PHONY : main
+
+# fast build rule for target.
+main/fast:
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/build
+.PHONY : main/fast
+
+#=============================================================================
+# Target rules for targets named mkvol.xtreemfs
+
+# Build rule for target.
+mkvol.xtreemfs: cmake_check_build_system
+ $(MAKE) -f CMakeFiles/Makefile2 mkvol.xtreemfs
+.PHONY : mkvol.xtreemfs
+
+# fast build rule for target.
+mkvol.xtreemfs/fast:
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/build
+.PHONY : mkvol.xtreemfs/fast
+
+generated/include/Common.pb.o: generated/include/Common.pb.cc.o
+.PHONY : generated/include/Common.pb.o
+
+# target to build an object file
+generated/include/Common.pb.cc.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/include/Common.pb.cc.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/include/Common.pb.cc.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/include/Common.pb.cc.o
+.PHONY : generated/include/Common.pb.cc.o
+
+generated/include/Common.pb.i: generated/include/Common.pb.cc.i
+.PHONY : generated/include/Common.pb.i
+
+# target to preprocess a source file
+generated/include/Common.pb.cc.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/include/Common.pb.cc.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/include/Common.pb.cc.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/include/Common.pb.cc.i
+.PHONY : generated/include/Common.pb.cc.i
+
+generated/include/Common.pb.s: generated/include/Common.pb.cc.s
+.PHONY : generated/include/Common.pb.s
+
+# target to generate assembly for a file
+generated/include/Common.pb.cc.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/include/Common.pb.cc.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/include/Common.pb.cc.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/include/Common.pb.cc.s
+.PHONY : generated/include/Common.pb.cc.s
+
+generated/include/PBRPC.pb.o: generated/include/PBRPC.pb.cc.o
+.PHONY : generated/include/PBRPC.pb.o
+
+# target to build an object file
+generated/include/PBRPC.pb.cc.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/include/PBRPC.pb.cc.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/include/PBRPC.pb.cc.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/include/PBRPC.pb.cc.o
+.PHONY : generated/include/PBRPC.pb.cc.o
+
+generated/include/PBRPC.pb.i: generated/include/PBRPC.pb.cc.i
+.PHONY : generated/include/PBRPC.pb.i
+
+# target to preprocess a source file
+generated/include/PBRPC.pb.cc.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/include/PBRPC.pb.cc.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/include/PBRPC.pb.cc.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/include/PBRPC.pb.cc.i
+.PHONY : generated/include/PBRPC.pb.cc.i
+
+generated/include/PBRPC.pb.s: generated/include/PBRPC.pb.cc.s
+.PHONY : generated/include/PBRPC.pb.s
+
+# target to generate assembly for a file
+generated/include/PBRPC.pb.cc.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/include/PBRPC.pb.cc.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/include/PBRPC.pb.cc.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/include/PBRPC.pb.cc.s
+.PHONY : generated/include/PBRPC.pb.cc.s
+
+generated/pbrpc/Ping.pb.o: generated/pbrpc/Ping.pb.cc.o
+.PHONY : generated/pbrpc/Ping.pb.o
+
+# target to build an object file
+generated/pbrpc/Ping.pb.cc.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/pbrpc/Ping.pb.cc.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/pbrpc/Ping.pb.cc.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/pbrpc/Ping.pb.cc.o
+.PHONY : generated/pbrpc/Ping.pb.cc.o
+
+generated/pbrpc/Ping.pb.i: generated/pbrpc/Ping.pb.cc.i
+.PHONY : generated/pbrpc/Ping.pb.i
+
+# target to preprocess a source file
+generated/pbrpc/Ping.pb.cc.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/pbrpc/Ping.pb.cc.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/pbrpc/Ping.pb.cc.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/pbrpc/Ping.pb.cc.i
+.PHONY : generated/pbrpc/Ping.pb.cc.i
+
+generated/pbrpc/Ping.pb.s: generated/pbrpc/Ping.pb.cc.s
+.PHONY : generated/pbrpc/Ping.pb.s
+
+# target to generate assembly for a file
+generated/pbrpc/Ping.pb.cc.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/pbrpc/Ping.pb.cc.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/pbrpc/Ping.pb.cc.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/pbrpc/Ping.pb.cc.s
+.PHONY : generated/pbrpc/Ping.pb.cc.s
+
+generated/pbrpc/RPC.pb.o: generated/pbrpc/RPC.pb.cc.o
+.PHONY : generated/pbrpc/RPC.pb.o
+
+# target to build an object file
+generated/pbrpc/RPC.pb.cc.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/pbrpc/RPC.pb.cc.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/pbrpc/RPC.pb.cc.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/pbrpc/RPC.pb.cc.o
+.PHONY : generated/pbrpc/RPC.pb.cc.o
+
+generated/pbrpc/RPC.pb.i: generated/pbrpc/RPC.pb.cc.i
+.PHONY : generated/pbrpc/RPC.pb.i
+
+# target to preprocess a source file
+generated/pbrpc/RPC.pb.cc.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/pbrpc/RPC.pb.cc.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/pbrpc/RPC.pb.cc.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/pbrpc/RPC.pb.cc.i
+.PHONY : generated/pbrpc/RPC.pb.cc.i
+
+generated/pbrpc/RPC.pb.s: generated/pbrpc/RPC.pb.cc.s
+.PHONY : generated/pbrpc/RPC.pb.s
+
+# target to generate assembly for a file
+generated/pbrpc/RPC.pb.cc.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/pbrpc/RPC.pb.cc.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/pbrpc/RPC.pb.cc.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/pbrpc/RPC.pb.cc.s
+.PHONY : generated/pbrpc/RPC.pb.cc.s
+
+generated/xtreemfs/DIR.pb.o: generated/xtreemfs/DIR.pb.cc.o
+.PHONY : generated/xtreemfs/DIR.pb.o
+
+# target to build an object file
+generated/xtreemfs/DIR.pb.cc.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/DIR.pb.cc.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/DIR.pb.cc.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/DIR.pb.cc.o
+.PHONY : generated/xtreemfs/DIR.pb.cc.o
+
+generated/xtreemfs/DIR.pb.i: generated/xtreemfs/DIR.pb.cc.i
+.PHONY : generated/xtreemfs/DIR.pb.i
+
+# target to preprocess a source file
+generated/xtreemfs/DIR.pb.cc.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/DIR.pb.cc.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/DIR.pb.cc.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/DIR.pb.cc.i
+.PHONY : generated/xtreemfs/DIR.pb.cc.i
+
+generated/xtreemfs/DIR.pb.s: generated/xtreemfs/DIR.pb.cc.s
+.PHONY : generated/xtreemfs/DIR.pb.s
+
+# target to generate assembly for a file
+generated/xtreemfs/DIR.pb.cc.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/DIR.pb.cc.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/DIR.pb.cc.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/DIR.pb.cc.s
+.PHONY : generated/xtreemfs/DIR.pb.cc.s
+
+generated/xtreemfs/GlobalTypes.pb.o: generated/xtreemfs/GlobalTypes.pb.cc.o
+.PHONY : generated/xtreemfs/GlobalTypes.pb.o
+
+# target to build an object file
+generated/xtreemfs/GlobalTypes.pb.cc.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/GlobalTypes.pb.cc.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/GlobalTypes.pb.cc.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/GlobalTypes.pb.cc.o
+.PHONY : generated/xtreemfs/GlobalTypes.pb.cc.o
+
+generated/xtreemfs/GlobalTypes.pb.i: generated/xtreemfs/GlobalTypes.pb.cc.i
+.PHONY : generated/xtreemfs/GlobalTypes.pb.i
+
+# target to preprocess a source file
+generated/xtreemfs/GlobalTypes.pb.cc.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/GlobalTypes.pb.cc.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/GlobalTypes.pb.cc.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/GlobalTypes.pb.cc.i
+.PHONY : generated/xtreemfs/GlobalTypes.pb.cc.i
+
+generated/xtreemfs/GlobalTypes.pb.s: generated/xtreemfs/GlobalTypes.pb.cc.s
+.PHONY : generated/xtreemfs/GlobalTypes.pb.s
+
+# target to generate assembly for a file
+generated/xtreemfs/GlobalTypes.pb.cc.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/GlobalTypes.pb.cc.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/GlobalTypes.pb.cc.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/GlobalTypes.pb.cc.s
+.PHONY : generated/xtreemfs/GlobalTypes.pb.cc.s
+
+generated/xtreemfs/MRC.pb.o: generated/xtreemfs/MRC.pb.cc.o
+.PHONY : generated/xtreemfs/MRC.pb.o
+
+# target to build an object file
+generated/xtreemfs/MRC.pb.cc.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/MRC.pb.cc.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/MRC.pb.cc.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/MRC.pb.cc.o
+.PHONY : generated/xtreemfs/MRC.pb.cc.o
+
+generated/xtreemfs/MRC.pb.i: generated/xtreemfs/MRC.pb.cc.i
+.PHONY : generated/xtreemfs/MRC.pb.i
+
+# target to preprocess a source file
+generated/xtreemfs/MRC.pb.cc.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/MRC.pb.cc.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/MRC.pb.cc.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/MRC.pb.cc.i
+.PHONY : generated/xtreemfs/MRC.pb.cc.i
+
+generated/xtreemfs/MRC.pb.s: generated/xtreemfs/MRC.pb.cc.s
+.PHONY : generated/xtreemfs/MRC.pb.s
+
+# target to generate assembly for a file
+generated/xtreemfs/MRC.pb.cc.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/MRC.pb.cc.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/MRC.pb.cc.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/MRC.pb.cc.s
+.PHONY : generated/xtreemfs/MRC.pb.cc.s
+
+generated/xtreemfs/OSD.pb.o: generated/xtreemfs/OSD.pb.cc.o
+.PHONY : generated/xtreemfs/OSD.pb.o
+
+# target to build an object file
+generated/xtreemfs/OSD.pb.cc.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/OSD.pb.cc.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/OSD.pb.cc.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/OSD.pb.cc.o
+.PHONY : generated/xtreemfs/OSD.pb.cc.o
+
+generated/xtreemfs/OSD.pb.i: generated/xtreemfs/OSD.pb.cc.i
+.PHONY : generated/xtreemfs/OSD.pb.i
+
+# target to preprocess a source file
+generated/xtreemfs/OSD.pb.cc.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/OSD.pb.cc.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/OSD.pb.cc.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/OSD.pb.cc.i
+.PHONY : generated/xtreemfs/OSD.pb.cc.i
+
+generated/xtreemfs/OSD.pb.s: generated/xtreemfs/OSD.pb.cc.s
+.PHONY : generated/xtreemfs/OSD.pb.s
+
+# target to generate assembly for a file
+generated/xtreemfs/OSD.pb.cc.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/generated/xtreemfs/OSD.pb.cc.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/generated/xtreemfs/OSD.pb.cc.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/generated/xtreemfs/OSD.pb.cc.s
+.PHONY : generated/xtreemfs/OSD.pb.cc.s
+
+src/fuse_test/fuse_client.o: src/fuse_test/fuse_client.cpp.o
+.PHONY : src/fuse_test/fuse_client.o
+
+# target to build an object file
+src/fuse_test/fuse_client.cpp.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/fuse_test/fuse_client.cpp.o
+.PHONY : src/fuse_test/fuse_client.cpp.o
+
+src/fuse_test/fuse_client.i: src/fuse_test/fuse_client.cpp.i
+.PHONY : src/fuse_test/fuse_client.i
+
+# target to preprocess a source file
+src/fuse_test/fuse_client.cpp.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/fuse_test/fuse_client.cpp.i
+.PHONY : src/fuse_test/fuse_client.cpp.i
+
+src/fuse_test/fuse_client.s: src/fuse_test/fuse_client.cpp.s
+.PHONY : src/fuse_test/fuse_client.s
+
+# target to generate assembly for a file
+src/fuse_test/fuse_client.cpp.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/fuse_test/fuse_client.cpp.s
+.PHONY : src/fuse_test/fuse_client.cpp.s
+
+src/fuse_test/mkvol_xtreemfs.o: src/fuse_test/mkvol_xtreemfs.cpp.o
+.PHONY : src/fuse_test/mkvol_xtreemfs.o
+
+# target to build an object file
+src/fuse_test/mkvol_xtreemfs.cpp.o:
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/fuse_test/mkvol_xtreemfs.cpp.o
+.PHONY : src/fuse_test/mkvol_xtreemfs.cpp.o
+
+src/fuse_test/mkvol_xtreemfs.i: src/fuse_test/mkvol_xtreemfs.cpp.i
+.PHONY : src/fuse_test/mkvol_xtreemfs.i
+
+# target to preprocess a source file
+src/fuse_test/mkvol_xtreemfs.cpp.i:
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/fuse_test/mkvol_xtreemfs.cpp.i
+.PHONY : src/fuse_test/mkvol_xtreemfs.cpp.i
+
+src/fuse_test/mkvol_xtreemfs.s: src/fuse_test/mkvol_xtreemfs.cpp.s
+.PHONY : src/fuse_test/mkvol_xtreemfs.s
+
+# target to generate assembly for a file
+src/fuse_test/mkvol_xtreemfs.cpp.s:
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/fuse_test/mkvol_xtreemfs.cpp.s
+.PHONY : src/fuse_test/mkvol_xtreemfs.cpp.s
+
+src/main.o: src/main.cpp.o
+.PHONY : src/main.o
+
+# target to build an object file
+src/main.cpp.o:
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/main.cpp.o
+.PHONY : src/main.cpp.o
+
+src/main.i: src/main.cpp.i
+.PHONY : src/main.i
+
+# target to preprocess a source file
+src/main.cpp.i:
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/main.cpp.i
+.PHONY : src/main.cpp.i
+
+src/main.s: src/main.cpp.s
+.PHONY : src/main.s
+
+# target to generate assembly for a file
+src/main.cpp.s:
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/main.cpp.s
+.PHONY : src/main.cpp.s
+
+src/rpc/client.o: src/rpc/client.cpp.o
+.PHONY : src/rpc/client.o
+
+# target to build an object file
+src/rpc/client.cpp.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client.cpp.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client.cpp.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client.cpp.o
+.PHONY : src/rpc/client.cpp.o
+
+src/rpc/client.i: src/rpc/client.cpp.i
+.PHONY : src/rpc/client.i
+
+# target to preprocess a source file
+src/rpc/client.cpp.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client.cpp.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client.cpp.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client.cpp.i
+.PHONY : src/rpc/client.cpp.i
+
+src/rpc/client.s: src/rpc/client.cpp.s
+.PHONY : src/rpc/client.s
+
+# target to generate assembly for a file
+src/rpc/client.cpp.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client.cpp.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client.cpp.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client.cpp.s
+.PHONY : src/rpc/client.cpp.s
+
+src/rpc/client_connection.o: src/rpc/client_connection.cpp.o
+.PHONY : src/rpc/client_connection.o
+
+# target to build an object file
+src/rpc/client_connection.cpp.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client_connection.cpp.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client_connection.cpp.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client_connection.cpp.o
+.PHONY : src/rpc/client_connection.cpp.o
+
+src/rpc/client_connection.i: src/rpc/client_connection.cpp.i
+.PHONY : src/rpc/client_connection.i
+
+# target to preprocess a source file
+src/rpc/client_connection.cpp.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client_connection.cpp.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client_connection.cpp.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client_connection.cpp.i
+.PHONY : src/rpc/client_connection.cpp.i
+
+src/rpc/client_connection.s: src/rpc/client_connection.cpp.s
+.PHONY : src/rpc/client_connection.s
+
+# target to generate assembly for a file
+src/rpc/client_connection.cpp.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client_connection.cpp.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client_connection.cpp.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client_connection.cpp.s
+.PHONY : src/rpc/client_connection.cpp.s
+
+src/rpc/client_request.o: src/rpc/client_request.cpp.o
+.PHONY : src/rpc/client_request.o
+
+# target to build an object file
+src/rpc/client_request.cpp.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client_request.cpp.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client_request.cpp.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client_request.cpp.o
+.PHONY : src/rpc/client_request.cpp.o
+
+src/rpc/client_request.i: src/rpc/client_request.cpp.i
+.PHONY : src/rpc/client_request.i
+
+# target to preprocess a source file
+src/rpc/client_request.cpp.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client_request.cpp.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client_request.cpp.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client_request.cpp.i
+.PHONY : src/rpc/client_request.cpp.i
+
+src/rpc/client_request.s: src/rpc/client_request.cpp.s
+.PHONY : src/rpc/client_request.s
+
+# target to generate assembly for a file
+src/rpc/client_request.cpp.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/client_request.cpp.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/client_request.cpp.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/client_request.cpp.s
+.PHONY : src/rpc/client_request.cpp.s
+
+src/rpc/record_marker.o: src/rpc/record_marker.cpp.o
+.PHONY : src/rpc/record_marker.o
+
+# target to build an object file
+src/rpc/record_marker.cpp.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/record_marker.cpp.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/record_marker.cpp.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/record_marker.cpp.o
+.PHONY : src/rpc/record_marker.cpp.o
+
+src/rpc/record_marker.i: src/rpc/record_marker.cpp.i
+.PHONY : src/rpc/record_marker.i
+
+# target to preprocess a source file
+src/rpc/record_marker.cpp.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/record_marker.cpp.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/record_marker.cpp.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/record_marker.cpp.i
+.PHONY : src/rpc/record_marker.cpp.i
+
+src/rpc/record_marker.s: src/rpc/record_marker.cpp.s
+.PHONY : src/rpc/record_marker.s
+
+# target to generate assembly for a file
+src/rpc/record_marker.cpp.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/rpc/record_marker.cpp.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/rpc/record_marker.cpp.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/rpc/record_marker.cpp.s
+.PHONY : src/rpc/record_marker.cpp.s
+
+src/util/logging.o: src/util/logging.cpp.o
+.PHONY : src/util/logging.o
+
+# target to build an object file
+src/util/logging.cpp.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/logging.cpp.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/logging.cpp.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/logging.cpp.o
+.PHONY : src/util/logging.cpp.o
+
+src/util/logging.i: src/util/logging.cpp.i
+.PHONY : src/util/logging.i
+
+# target to preprocess a source file
+src/util/logging.cpp.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/logging.cpp.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/logging.cpp.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/logging.cpp.i
+.PHONY : src/util/logging.cpp.i
+
+src/util/logging.s: src/util/logging.cpp.s
+.PHONY : src/util/logging.s
+
+# target to generate assembly for a file
+src/util/logging.cpp.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/logging.cpp.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/logging.cpp.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/logging.cpp.s
+.PHONY : src/util/logging.cpp.s
+
+src/util/pbrpc_url.o: src/util/pbrpc_url.cpp.o
+.PHONY : src/util/pbrpc_url.o
+
+# target to build an object file
+src/util/pbrpc_url.cpp.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/pbrpc_url.cpp.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/pbrpc_url.cpp.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/pbrpc_url.cpp.o
+.PHONY : src/util/pbrpc_url.cpp.o
+
+src/util/pbrpc_url.i: src/util/pbrpc_url.cpp.i
+.PHONY : src/util/pbrpc_url.i
+
+# target to preprocess a source file
+src/util/pbrpc_url.cpp.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/pbrpc_url.cpp.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/pbrpc_url.cpp.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/pbrpc_url.cpp.i
+.PHONY : src/util/pbrpc_url.cpp.i
+
+src/util/pbrpc_url.s: src/util/pbrpc_url.cpp.s
+.PHONY : src/util/pbrpc_url.s
+
+# target to generate assembly for a file
+src/util/pbrpc_url.cpp.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/pbrpc_url.cpp.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/pbrpc_url.cpp.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/pbrpc_url.cpp.s
+.PHONY : src/util/pbrpc_url.cpp.s
+
+src/util/user_mapping.o: src/util/user_mapping.cpp.o
+.PHONY : src/util/user_mapping.o
+
+# target to build an object file
+src/util/user_mapping.cpp.o:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/user_mapping.cpp.o
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/user_mapping.cpp.o
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/user_mapping.cpp.o
+.PHONY : src/util/user_mapping.cpp.o
+
+src/util/user_mapping.i: src/util/user_mapping.cpp.i
+.PHONY : src/util/user_mapping.i
+
+# target to preprocess a source file
+src/util/user_mapping.cpp.i:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/user_mapping.cpp.i
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/user_mapping.cpp.i
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/user_mapping.cpp.i
+.PHONY : src/util/user_mapping.cpp.i
+
+src/util/user_mapping.s: src/util/user_mapping.cpp.s
+.PHONY : src/util/user_mapping.s
+
+# target to generate assembly for a file
+src/util/user_mapping.cpp.s:
+ $(MAKE) -f CMakeFiles/fusetest.dir/build.make CMakeFiles/fusetest.dir/src/util/user_mapping.cpp.s
+ $(MAKE) -f CMakeFiles/main.dir/build.make CMakeFiles/main.dir/src/util/user_mapping.cpp.s
+ $(MAKE) -f CMakeFiles/mkvol.xtreemfs.dir/build.make CMakeFiles/mkvol.xtreemfs.dir/src/util/user_mapping.cpp.s
+.PHONY : src/util/user_mapping.cpp.s
+
+# Help Target
+help:
+ @echo "The following are some of the valid targets for this Makefile:"
+ @echo "... all (the default if no target is provided)"
+ @echo "... clean"
+ @echo "... depend"
+ @echo "... edit_cache"
+ @echo "... fusetest"
+ @echo "... main"
+ @echo "... mkvol.xtreemfs"
+ @echo "... rebuild_cache"
+ @echo "... generated/include/Common.pb.o"
+ @echo "... generated/include/Common.pb.i"
+ @echo "... generated/include/Common.pb.s"
+ @echo "... generated/include/PBRPC.pb.o"
+ @echo "... generated/include/PBRPC.pb.i"
+ @echo "... generated/include/PBRPC.pb.s"
+ @echo "... generated/pbrpc/Ping.pb.o"
+ @echo "... generated/pbrpc/Ping.pb.i"
+ @echo "... generated/pbrpc/Ping.pb.s"
+ @echo "... generated/pbrpc/RPC.pb.o"
+ @echo "... generated/pbrpc/RPC.pb.i"
+ @echo "... generated/pbrpc/RPC.pb.s"
+ @echo "... generated/xtreemfs/DIR.pb.o"
+ @echo "... generated/xtreemfs/DIR.pb.i"
+ @echo "... generated/xtreemfs/DIR.pb.s"
+ @echo "... generated/xtreemfs/GlobalTypes.pb.o"
+ @echo "... generated/xtreemfs/GlobalTypes.pb.i"
+ @echo "... generated/xtreemfs/GlobalTypes.pb.s"
+ @echo "... generated/xtreemfs/MRC.pb.o"
+ @echo "... generated/xtreemfs/MRC.pb.i"
+ @echo "... generated/xtreemfs/MRC.pb.s"
+ @echo "... generated/xtreemfs/OSD.pb.o"
+ @echo "... generated/xtreemfs/OSD.pb.i"
+ @echo "... generated/xtreemfs/OSD.pb.s"
+ @echo "... src/fuse_test/fuse_client.o"
+ @echo "... src/fuse_test/fuse_client.i"
+ @echo "... src/fuse_test/fuse_client.s"
+ @echo "... src/fuse_test/mkvol_xtreemfs.o"
+ @echo "... src/fuse_test/mkvol_xtreemfs.i"
+ @echo "... src/fuse_test/mkvol_xtreemfs.s"
+ @echo "... src/main.o"
+ @echo "... src/main.i"
+ @echo "... src/main.s"
+ @echo "... src/rpc/client.o"
+ @echo "... src/rpc/client.i"
+ @echo "... src/rpc/client.s"
+ @echo "... src/rpc/client_connection.o"
+ @echo "... src/rpc/client_connection.i"
+ @echo "... src/rpc/client_connection.s"
+ @echo "... src/rpc/client_request.o"
+ @echo "... src/rpc/client_request.i"
+ @echo "... src/rpc/client_request.s"
+ @echo "... src/rpc/record_marker.o"
+ @echo "... src/rpc/record_marker.i"
+ @echo "... src/rpc/record_marker.s"
+ @echo "... src/util/logging.o"
+ @echo "... src/util/logging.i"
+ @echo "... src/util/logging.s"
+ @echo "... src/util/pbrpc_url.o"
+ @echo "... src/util/pbrpc_url.i"
+ @echo "... src/util/pbrpc_url.s"
+ @echo "... src/util/user_mapping.o"
+ @echo "... src/util/user_mapping.i"
+ @echo "... src/util/user_mapping.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+ $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/cpp/cpp_prj/.dep.inc b/cpp/cpp_prj/.dep.inc
new file mode 100644
index 0000000000000000000000000000000000000000..4560e55af987875b237a8ceb4c29b383c6575292
--- /dev/null
+++ b/cpp/cpp_prj/.dep.inc
@@ -0,0 +1,5 @@
+# This code depends on make tool being used
+DEPFILES=$(wildcard $(addsuffix .d, ${OBJECTFILES}))
+ifneq (${DEPFILES},)
+include ${DEPFILES}
+endif
diff --git a/cpp/cpp_prj/cpp_prj-Makefile.mk b/cpp/cpp_prj/cpp_prj-Makefile.mk
new file mode 100644
index 0000000000000000000000000000000000000000..ec9de690e53a4d149efe22428359088b44605367
--- /dev/null
+++ b/cpp/cpp_prj/cpp_prj-Makefile.mk
@@ -0,0 +1,128 @@
+#
+# There exist several targets which are by default empty and which can be
+# used for execution of your targets. These targets are usually executed
+# before and after some main targets. They are:
+#
+# .build-pre: called before 'build' target
+# .build-post: called after 'build' target
+# .clean-pre: called before 'clean' target
+# .clean-post: called after 'clean' target
+# .clobber-pre: called before 'clobber' target
+# .clobber-post: called after 'clobber' target
+# .all-pre: called before 'all' target
+# .all-post: called after 'all' target
+# .help-pre: called before 'help' target
+# .help-post: called after 'help' target
+#
+# Targets beginning with '.' are not intended to be called on their own.
+#
+# Main targets can be executed directly, and they are:
+#
+# build build a specific configuration
+# clean remove built files from a configuration
+# clobber remove all built files
+# all build all configurations
+# help print help mesage
+#
+# Targets .build-impl, .clean-impl, .clobber-impl, .all-impl, and
+# .help-impl are implemented in nbproject/makefile-impl.mk.
+#
+# Available make variables:
+#
+# CND_BASEDIR base directory for relative paths
+# CND_DISTDIR default top distribution directory (build artifacts)
+# CND_BUILDDIR default top build directory (object files, ...)
+# CONF name of current configuration
+# CND_PLATFORM_${CONF} platform name (current configuration)
+# CND_ARTIFACT_DIR_${CONF} directory of build artifact (current configuration)
+# CND_ARTIFACT_NAME_${CONF} name of build artifact (current configuration)
+# CND_ARTIFACT_PATH_${CONF} path to build artifact (current configuration)
+# CND_PACKAGE_DIR_${CONF} directory of package (current configuration)
+# CND_PACKAGE_NAME_${CONF} name of package (current configuration)
+# CND_PACKAGE_PATH_${CONF} path to package (current configuration)
+#
+# NOCDDL
+
+
+# Environment
+MKDIR=mkdir
+CP=cp
+CCADMIN=CCadmin
+
+
+# build
+build: .build-post
+
+.build-pre:
+# Add your pre 'build' code here...
+
+.build-post: .build-impl
+# Add your post 'build' code here...
+
+
+# clean
+clean: .clean-post
+
+.clean-pre:
+# Add your pre 'clean' code here...
+
+.clean-post: .clean-impl
+# Add your post 'clean' code here...
+
+
+# clobber
+clobber: .clobber-post
+
+.clobber-pre:
+# Add your pre 'clobber' code here...
+
+.clobber-post: .clobber-impl
+# Add your post 'clobber' code here...
+
+
+# all
+all: .all-post
+
+.all-pre:
+# Add your pre 'all' code here...
+
+.all-post: .all-impl
+# Add your post 'all' code here...
+
+
+# build tests
+build-tests: .build-tests-post
+
+.build-tests-pre:
+# Add your pre 'build-tests' code here...
+
+.build-tests-post: .build-tests-impl
+# Add your post 'build-tests' code here...
+
+
+# run tests
+test: .test-post
+
+.test-pre:
+# Add your pre 'test' code here...
+
+.test-post: .test-impl
+# Add your post 'test' code here...
+
+
+# help
+help: .help-post
+
+.help-pre:
+# Add your pre 'help' code here...
+
+.help-post: .help-impl
+# Add your post 'help' code here...
+
+
+
+# include project implementation makefile
+include nbproject/Makefile-impl.mk
+
+# include project make variables
+include nbproject/Makefile-variables.mk
diff --git a/cpp/cpp_prj/nbproject/Makefile-Default.mk b/cpp/cpp_prj/nbproject/Makefile-Default.mk
new file mode 100644
index 0000000000000000000000000000000000000000..f763f28d2ae61e0b65a646f2b4702c91ac8d7b3b
--- /dev/null
+++ b/cpp/cpp_prj/nbproject/Makefile-Default.mk
@@ -0,0 +1,66 @@
+#
+# Generated Makefile - do not edit!
+#
+# Edit the Makefile in the project folder instead (../Makefile). Each target
+# has a -pre and a -post target defined where you can add customized code.
+#
+# This makefile implements configuration specific macros and targets.
+
+
+# Environment
+MKDIR=mkdir
+CP=cp
+GREP=grep
+NM=nm
+CCADMIN=CCadmin
+RANLIB=ranlib
+CC=gcc
+CCC=g++
+CXX=g++
+FC=
+AS=as
+
+# Macros
+CND_PLATFORM=GNU-Linux-x86
+CND_CONF=Default
+CND_DISTDIR=dist
+
+# Include project Makefile
+include cpp_prj-Makefile.mk
+
+# Object Directory
+OBJECTDIR=build/${CND_CONF}/${CND_PLATFORM}
+
+# Object Files
+OBJECTFILES=
+
+
+# C Compiler Flags
+CFLAGS=
+
+# CC Compiler Flags
+CCFLAGS=
+CXXFLAGS=
+
+# Fortran Compiler Flags
+FFLAGS=
+
+# Assembler Flags
+ASFLAGS=
+
+# Link Libraries and Options
+LDLIBSOPTIONS=
+
+# Build Targets
+.build-conf: ${BUILD_SUBPROJECTS}
+ cd .. && ${MAKE} -f Makefile
+
+# Subprojects
+.build-subprojects:
+
+# Clean Targets
+.clean-conf: ${CLEAN_SUBPROJECTS}
+ cd .. && ${MAKE} -f Makefile clean
+
+# Subprojects
+.clean-subprojects:
diff --git a/cpp/cpp_prj/nbproject/Makefile-impl.mk b/cpp/cpp_prj/nbproject/Makefile-impl.mk
new file mode 100644
index 0000000000000000000000000000000000000000..41e48c2284a1acaa6d7193413d306c2e3ca4ec29
--- /dev/null
+++ b/cpp/cpp_prj/nbproject/Makefile-impl.mk
@@ -0,0 +1,133 @@
+#
+# Generated Makefile - do not edit!
+#
+# Edit the Makefile in the project folder instead (../Makefile). Each target
+# has a pre- and a post- target defined where you can add customization code.
+#
+# This makefile implements macros and targets common to all configurations.
+#
+# NOCDDL
+
+
+# Building and Cleaning subprojects are done by default, but can be controlled with the SUB
+# macro. If SUB=no, subprojects will not be built or cleaned. The following macro
+# statements set BUILD_SUB-CONF and CLEAN_SUB-CONF to .build-reqprojects-conf
+# and .clean-reqprojects-conf unless SUB has the value 'no'
+SUB_no=NO
+SUBPROJECTS=${SUB_${SUB}}
+BUILD_SUBPROJECTS_=.build-subprojects
+BUILD_SUBPROJECTS_NO=
+BUILD_SUBPROJECTS=${BUILD_SUBPROJECTS_${SUBPROJECTS}}
+CLEAN_SUBPROJECTS_=.clean-subprojects
+CLEAN_SUBPROJECTS_NO=
+CLEAN_SUBPROJECTS=${CLEAN_SUBPROJECTS_${SUBPROJECTS}}
+
+
+# Project Name
+PROJECTNAME=cpp_prj
+
+# Active Configuration
+DEFAULTCONF=Default
+CONF=${DEFAULTCONF}
+
+# All Configurations
+ALLCONFS=Default
+
+
+# build
+.build-impl: .build-pre .validate-impl .depcheck-impl
+ @#echo "=> Running $@... Configuration=$(CONF)"
+ "${MAKE}" -f nbproject/Makefile-${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .build-conf
+
+
+# clean
+.clean-impl: .clean-pre .validate-impl .depcheck-impl
+ @#echo "=> Running $@... Configuration=$(CONF)"
+ "${MAKE}" -f nbproject/Makefile-${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .clean-conf
+
+
+# clobber
+.clobber-impl: .clobber-pre .depcheck-impl
+ @#echo "=> Running $@..."
+ for CONF in ${ALLCONFS}; \
+ do \
+ "${MAKE}" -f nbproject/Makefile-$${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .clean-conf; \
+ done
+
+# all
+.all-impl: .all-pre .depcheck-impl
+ @#echo "=> Running $@..."
+ for CONF in ${ALLCONFS}; \
+ do \
+ "${MAKE}" -f nbproject/Makefile-$${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .build-conf; \
+ done
+
+# build tests
+.build-tests-impl: .build-impl .build-tests-pre
+ @#echo "=> Running $@... Configuration=$(CONF)"
+ "${MAKE}" -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .build-tests-conf
+
+# run tests
+.test-impl: .build-tests-impl .test-pre
+ @#echo "=> Running $@... Configuration=$(CONF)"
+ "${MAKE}" -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .test-conf
+
+# dependency checking support
+.depcheck-impl:
+ @echo "# This code depends on make tool being used" >.dep.inc
+ @if [ -n "${MAKE_VERSION}" ]; then \
+ echo "DEPFILES=\$$(wildcard \$$(addsuffix .d, \$${OBJECTFILES}))" >>.dep.inc; \
+ echo "ifneq (\$${DEPFILES},)" >>.dep.inc; \
+ echo "include \$${DEPFILES}" >>.dep.inc; \
+ echo "endif" >>.dep.inc; \
+ else \
+ echo ".KEEP_STATE:" >>.dep.inc; \
+ echo ".KEEP_STATE_FILE:.make.state.\$${CONF}" >>.dep.inc; \
+ fi
+
+# configuration validation
+.validate-impl:
+ @if [ ! -f nbproject/Makefile-${CONF}.mk ]; \
+ then \
+ echo ""; \
+ echo "Error: can not find the makefile for configuration '${CONF}' in project ${PROJECTNAME}"; \
+ echo "See 'make help' for details."; \
+ echo "Current directory: " `pwd`; \
+ echo ""; \
+ fi
+ @if [ ! -f nbproject/Makefile-${CONF}.mk ]; \
+ then \
+ exit 1; \
+ fi
+
+
+# help
+.help-impl: .help-pre
+ @echo "This makefile supports the following configurations:"
+ @echo " ${ALLCONFS}"
+ @echo ""
+ @echo "and the following targets:"
+ @echo " build (default target)"
+ @echo " clean"
+ @echo " clobber"
+ @echo " all"
+ @echo " help"
+ @echo ""
+ @echo "Makefile Usage:"
+ @echo " make [CONF=] [SUB=no] build"
+ @echo " make [CONF=] [SUB=no] clean"
+ @echo " make [SUB=no] clobber"
+ @echo " make [SUB=no] all"
+ @echo " make help"
+ @echo ""
+ @echo "Target 'build' will build a specific configuration and, unless 'SUB=no',"
+ @echo " also build subprojects."
+ @echo "Target 'clean' will clean a specific configuration and, unless 'SUB=no',"
+ @echo " also clean subprojects."
+ @echo "Target 'clobber' will remove all built files from all configurations and,"
+ @echo " unless 'SUB=no', also from subprojects."
+ @echo "Target 'all' will will build all configurations and, unless 'SUB=no',"
+ @echo " also build subprojects."
+ @echo "Target 'help' prints this message."
+ @echo ""
+
diff --git a/cpp/cpp_prj/nbproject/Makefile-variables.mk b/cpp/cpp_prj/nbproject/Makefile-variables.mk
new file mode 100644
index 0000000000000000000000000000000000000000..1dd487ffa8ba46b92e716c5a74b157009bd24818
--- /dev/null
+++ b/cpp/cpp_prj/nbproject/Makefile-variables.mk
@@ -0,0 +1,16 @@
+#
+# Generated - do not edit!
+#
+# NOCDDL
+#
+CND_BASEDIR=`pwd`
+CND_BUILDDIR=build
+CND_DISTDIR=dist
+# Default configuration
+CND_PLATFORM_Default=GNU-Linux-x86
+CND_ARTIFACT_DIR_Default=..
+CND_ARTIFACT_NAME_Default=fusetest
+CND_ARTIFACT_PATH_Default=../fusetest
+CND_PACKAGE_DIR_Default=dist/Default/GNU-Linux-x86/package
+CND_PACKAGE_NAME_Default=cppprj.tar
+CND_PACKAGE_PATH_Default=dist/Default/GNU-Linux-x86/package/cppprj.tar
diff --git a/cpp/cpp_prj/nbproject/Package-Default.bash b/cpp/cpp_prj/nbproject/Package-Default.bash
new file mode 100644
index 0000000000000000000000000000000000000000..d994f7522674ff6a39d66dcff91662496696d324
--- /dev/null
+++ b/cpp/cpp_prj/nbproject/Package-Default.bash
@@ -0,0 +1,74 @@
+#!/bin/bash -x
+
+#
+# Generated - do not edit!
+#
+
+# Macros
+TOP=`pwd`
+CND_PLATFORM=GNU-Linux-x86
+CND_CONF=Default
+CND_DISTDIR=dist
+NBTMPDIR=build/${CND_CONF}/${CND_PLATFORM}/tmp-packaging
+TMPDIRNAME=tmp-packaging
+OUTPUT_PATH=../fusetest
+OUTPUT_BASENAME=fusetest
+PACKAGE_TOP_DIR=cppprj/
+
+# Functions
+function checkReturnCode
+{
+ rc=$?
+ if [ $rc != 0 ]
+ then
+ exit $rc
+ fi
+}
+function makeDirectory
+# $1 directory path
+# $2 permission (optional)
+{
+ mkdir -p "$1"
+ checkReturnCode
+ if [ "$2" != "" ]
+ then
+ chmod $2 "$1"
+ checkReturnCode
+ fi
+}
+function copyFileToTmpDir
+# $1 from-file path
+# $2 to-file path
+# $3 permission
+{
+ cp "$1" "$2"
+ checkReturnCode
+ if [ "$3" != "" ]
+ then
+ chmod $3 "$2"
+ checkReturnCode
+ fi
+}
+
+# Setup
+cd "${TOP}"
+mkdir -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package
+rm -rf ${NBTMPDIR}
+mkdir -p ${NBTMPDIR}
+
+# Copy files and create directories and links
+cd "${TOP}"
+makeDirectory "${NBTMPDIR}/cppprj/bin"
+copyFileToTmpDir "${OUTPUT_PATH}" "${NBTMPDIR}/${PACKAGE_TOP_DIR}bin/${OUTPUT_BASENAME}" 0755
+
+
+# Generate tar file
+cd "${TOP}"
+rm -f ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/cppprj.tar
+cd ${NBTMPDIR}
+tar -vcf ../../../../${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/cppprj.tar *
+checkReturnCode
+
+# Cleanup
+cd "${TOP}"
+rm -rf ${NBTMPDIR}
diff --git a/cpp/cpp_prj/nbproject/configurations.xml b/cpp/cpp_prj/nbproject/configurations.xml
new file mode 100644
index 0000000000000000000000000000000000000000..28dce16f1c14a06799b945e9fee7878c930e1f37
--- /dev/null
+++ b/cpp/cpp_prj/nbproject/configurations.xml
@@ -0,0 +1,137 @@
+
+
+
+
+
+ Common.pb.cc
+ Common.pb.h
+ PBRPC.pb.cc
+ PBRPC.pb.h
+
+
+ Ping.pb.cc
+ Ping.pb.h
+ PingServiceClient.h
+ RPC.pb.cc
+ RPC.pb.h
+
+
+ DIR.pb.cc
+ DIR.pb.h
+ DIRServiceClient.h
+ GlobalTypes.pb.cc
+ GlobalTypes.pb.h
+ MRC.pb.cc
+ MRC.pb.h
+ MRCServiceClient.h
+ OSD.pb.cc
+ OSD.pb.h
+ OSDServiceClient.h
+
+
+
+
+ abstract_socket_channel.h
+ callback_interface.h
+ client.h
+ client_connection.h
+ client_request.h
+ client_request_callback_interface.h
+ grid_ssl_socket_channel.h
+ record_marker.h
+ ssl_options.h
+ ssl_socket_channel.h
+ sync_callback.h
+ tcp_socket_channel.h
+
+
+ logging.h
+ pbrpc_url.h
+ user_mapping.h
+
+
+
+
+ fuse_client.cpp
+ mkvol_xtreemfs.cpp
+
+
+ client.cpp
+ client_connection.cpp
+ client_request.cpp
+ record_marker.cpp
+
+
+ logging.cpp
+ pbrpc_url.cpp
+ user_mapping.cpp
+
+ main.cpp
+
+
+ ../CMakeLists.txt
+ ../Makefile
+ cpp_prj-Makefile.mk
+
+
+
+ ../src
+ ../generated
+ ../include
+
+ cpp_prj-Makefile.mk
+
+
+
+ localhost
+ GNU|GNU
+ 2
+
+
+
+ ..
+ ${MAKE} -f Makefile
+ ${MAKE} -f Makefile clean
+ ../fusetest
+
+
+ ../generated
+ ../include
+
+
+
+
+ -
+
+
+ ../generated
+
+
+
+ -
+
+
+ ../generated
+
+
+
+
+
+
+ ../generated
+
+
+
+
+
+
+ ../include/rpc
+
+
+
+
+
+
diff --git a/cpp/cpp_prj/nbproject/private/configurations.xml b/cpp/cpp_prj/nbproject/private/configurations.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3a36d13c6c65844bdf32b29dd33619dbc46f2992
--- /dev/null
+++ b/cpp/cpp_prj/nbproject/private/configurations.xml
@@ -0,0 +1,21 @@
+
+
+ cpp_prj-Makefile.mk
+ 0
+
+
+
+
+
+ /home/bjko/mnt
+
+ true
+ 0
+ 0
+ 0
+
+
+
+
+
+
diff --git a/cpp/cpp_prj/nbproject/private/private.properties b/cpp/cpp_prj/nbproject/private/private.properties
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/cpp/cpp_prj/nbproject/private/private.xml b/cpp/cpp_prj/nbproject/private/private.xml
new file mode 100644
index 0000000000000000000000000000000000000000..bf91c93b1afbafb034105ed94fe08abd67a24447
--- /dev/null
+++ b/cpp/cpp_prj/nbproject/private/private.xml
@@ -0,0 +1,7 @@
+
+
+
+ true
+
+
+
diff --git a/cpp/cpp_prj/nbproject/project.properties b/cpp/cpp_prj/nbproject/project.properties
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/cpp/cpp_prj/nbproject/project.xml b/cpp/cpp_prj/nbproject/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..fa8dde0b89f980781499125b246cf7b3dcc65e75
--- /dev/null
+++ b/cpp/cpp_prj/nbproject/project.xml
@@ -0,0 +1,23 @@
+
+
+ org.netbeans.modules.cnd.makeproject
+
+
+ cpp_prj
+ 0
+
+ cc,cpp
+ h
+ UTF-8
+
+
+ ../src
+ ../generated
+ ../include
+
+
+ Default
+
+
+
+
diff --git a/cpp/generated/include/Common.pb.cc b/cpp/generated/include/Common.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e65bf7af01f07c0083ab783b1baf8a067607fede
--- /dev/null
+++ b/cpp/generated/include/Common.pb.cc
@@ -0,0 +1,431 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "include/Common.pb.h"
+#include
+#include
+#include
+#include
+#include
+#include
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+namespace {
+
+const ::google::protobuf::Descriptor* emptyRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ emptyRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* emptyResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ emptyResponse_reflection_ = NULL;
+
+} // namespace
+
+
+void protobuf_AssignDesc_include_2fCommon_2eproto() {
+ protobuf_AddDesc_include_2fCommon_2eproto();
+ const ::google::protobuf::FileDescriptor* file =
+ ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+ "include/Common.proto");
+ GOOGLE_CHECK(file != NULL);
+ emptyRequest_descriptor_ = file->message_type(0);
+ static const int emptyRequest_offsets_[1] = {
+ };
+ emptyRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ emptyRequest_descriptor_,
+ emptyRequest::default_instance_,
+ emptyRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(emptyRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(emptyRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(emptyRequest));
+ emptyResponse_descriptor_ = file->message_type(1);
+ static const int emptyResponse_offsets_[1] = {
+ };
+ emptyResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ emptyResponse_descriptor_,
+ emptyResponse::default_instance_,
+ emptyResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(emptyResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(emptyResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(emptyResponse));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+ ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+ &protobuf_AssignDesc_include_2fCommon_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ emptyRequest_descriptor_, &emptyRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ emptyResponse_descriptor_, &emptyResponse::default_instance());
+}
+
+} // namespace
+
+void protobuf_ShutdownFile_include_2fCommon_2eproto() {
+ delete emptyRequest::default_instance_;
+ delete emptyRequest_reflection_;
+ delete emptyResponse::default_instance_;
+ delete emptyResponse_reflection_;
+}
+
+void protobuf_AddDesc_include_2fCommon_2eproto() {
+ static bool already_here = false;
+ if (already_here) return;
+ already_here = true;
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+ "\n\024include/Common.proto\022\016xtreemfs.pbrpc\"\016"
+ "\n\014emptyRequest\"\017\n\remptyResponseB(\n&org.x"
+ "treemfs.pbrpc.generatedinterfaces", 113);
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+ "include/Common.proto", &protobuf_RegisterTypes);
+ emptyRequest::default_instance_ = new emptyRequest();
+ emptyResponse::default_instance_ = new emptyResponse();
+ emptyRequest::default_instance_->InitAsDefaultInstance();
+ emptyResponse::default_instance_->InitAsDefaultInstance();
+ ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_include_2fCommon_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_include_2fCommon_2eproto {
+ StaticDescriptorInitializer_include_2fCommon_2eproto() {
+ protobuf_AddDesc_include_2fCommon_2eproto();
+ }
+} static_descriptor_initializer_include_2fCommon_2eproto_;
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif // !_MSC_VER
+
+emptyRequest::emptyRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void emptyRequest::InitAsDefaultInstance() {
+}
+
+emptyRequest::emptyRequest(const emptyRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void emptyRequest::SharedCtor() {
+ _cached_size_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+emptyRequest::~emptyRequest() {
+ SharedDtor();
+}
+
+void emptyRequest::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void emptyRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* emptyRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return emptyRequest_descriptor_;
+}
+
+const emptyRequest& emptyRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_include_2fCommon_2eproto(); return *default_instance_;
+}
+
+emptyRequest* emptyRequest::default_instance_ = NULL;
+
+emptyRequest* emptyRequest::New() const {
+ return new emptyRequest;
+}
+
+void emptyRequest::Clear() {
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool emptyRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ }
+ return true;
+#undef DO_
+}
+
+void emptyRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* emptyRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int emptyRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void emptyRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const emptyRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void emptyRequest::MergeFrom(const emptyRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void emptyRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void emptyRequest::CopyFrom(const emptyRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool emptyRequest::IsInitialized() const {
+
+ return true;
+}
+
+void emptyRequest::Swap(emptyRequest* other) {
+ if (other != this) {
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata emptyRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = emptyRequest_descriptor_;
+ metadata.reflection = emptyRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif // !_MSC_VER
+
+emptyResponse::emptyResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void emptyResponse::InitAsDefaultInstance() {
+}
+
+emptyResponse::emptyResponse(const emptyResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void emptyResponse::SharedCtor() {
+ _cached_size_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+emptyResponse::~emptyResponse() {
+ SharedDtor();
+}
+
+void emptyResponse::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void emptyResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* emptyResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return emptyResponse_descriptor_;
+}
+
+const emptyResponse& emptyResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_include_2fCommon_2eproto(); return *default_instance_;
+}
+
+emptyResponse* emptyResponse::default_instance_ = NULL;
+
+emptyResponse* emptyResponse::New() const {
+ return new emptyResponse;
+}
+
+void emptyResponse::Clear() {
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool emptyResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ }
+ return true;
+#undef DO_
+}
+
+void emptyResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* emptyResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int emptyResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void emptyResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const emptyResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void emptyResponse::MergeFrom(const emptyResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void emptyResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void emptyResponse::CopyFrom(const emptyResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool emptyResponse::IsInitialized() const {
+
+ return true;
+}
+
+void emptyResponse::Swap(emptyResponse* other) {
+ if (other != this) {
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata emptyResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = emptyResponse_descriptor_;
+ metadata.reflection = emptyResponse_reflection_;
+ return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/cpp/generated/include/Common.pb.h b/cpp/generated/include/Common.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..c05902c887c7ef3651277becbc3aa915f6617d9f
--- /dev/null
+++ b/cpp/generated/include/Common.pb.h
@@ -0,0 +1,229 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: include/Common.proto
+
+#ifndef PROTOBUF_include_2fCommon_2eproto__INCLUDED
+#define PROTOBUF_include_2fCommon_2eproto__INCLUDED
+
+#include
+
+#include
+
+#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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
+#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
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+// Internal implementation detail -- do not call these.
+void protobuf_AddDesc_include_2fCommon_2eproto();
+void protobuf_AssignDesc_include_2fCommon_2eproto();
+void protobuf_ShutdownFile_include_2fCommon_2eproto();
+
+class emptyRequest;
+class emptyResponse;
+
+// ===================================================================
+
+class emptyRequest : public ::google::protobuf::Message {
+ public:
+ emptyRequest();
+ virtual ~emptyRequest();
+
+ emptyRequest(const emptyRequest& from);
+
+ inline emptyRequest& operator=(const emptyRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const emptyRequest& default_instance();
+
+ void Swap(emptyRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ emptyRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const emptyRequest& from);
+ void MergeFrom(const emptyRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.emptyRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class emptyResponse : public ::google::protobuf::Message {
+ public:
+ emptyResponse();
+ virtual ~emptyResponse();
+
+ emptyResponse(const emptyResponse& from);
+
+ inline emptyResponse& operator=(const emptyResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const emptyResponse& default_instance();
+
+ void Swap(emptyResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ emptyResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const emptyResponse& from);
+ void MergeFrom(const emptyResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.emptyResponse)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ 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_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// emptyRequest
+
+// -------------------------------------------------------------------
+
+// emptyResponse
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+} // namespace google
+} // namespace protobuf
+#endif // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif // PROTOBUF_include_2fCommon_2eproto__INCLUDED
diff --git a/cpp/generated/include/PBRPC.pb.cc b/cpp/generated/include/PBRPC.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6e4f642af327cc8f1793a893ba58fa4064320d8a
--- /dev/null
+++ b/cpp/generated/include/PBRPC.pb.cc
@@ -0,0 +1,106 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "include/PBRPC.pb.h"
+#include
+#include
+#include
+#include
+#include
+#include
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+namespace {
+
+
+} // namespace
+
+
+void protobuf_AssignDesc_include_2fPBRPC_2eproto() {
+ protobuf_AddDesc_include_2fPBRPC_2eproto();
+ const ::google::protobuf::FileDescriptor* file =
+ ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+ "include/PBRPC.proto");
+ GOOGLE_CHECK(file != NULL);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+ ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+ &protobuf_AssignDesc_include_2fPBRPC_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+ protobuf_AssignDescriptorsOnce();
+}
+
+} // namespace
+
+void protobuf_ShutdownFile_include_2fPBRPC_2eproto() {
+}
+
+void protobuf_AddDesc_include_2fPBRPC_2eproto() {
+ static bool already_here = false;
+ if (already_here) return;
+ already_here = true;
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
+ ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+ "\n\023include/PBRPC.proto\022\016xtreemfs.pbrpc\032 g"
+ "oogle/protobuf/descriptor.proto:1\n\007proc_"
+ "id\022\036.google.protobuf.MethodOptions\030\321\206\003 \001"
+ "(\007:1\n\007data_in\022\036.google.protobuf.MethodOp"
+ "tions\030\324\206\003 \001(\010:2\n\010data_out\022\036.google.proto"
+ "buf.MethodOptions\030\323\206\003 \001(\010:7\n\014interface_i"
+ "d\022\037.google.protobuf.ServiceOptions\030\322\206\003 \001"
+ "(\007B3\n1org.xtreemfs.foundation.pbrpc.gene"
+ "ratedinterfaces", 335);
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+ "include/PBRPC.proto", &protobuf_RegisterTypes);
+ ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+ &::google::protobuf::MethodOptions::default_instance(),
+ 50001, 7, false, false);
+ ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+ &::google::protobuf::MethodOptions::default_instance(),
+ 50004, 8, false, false);
+ ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+ &::google::protobuf::MethodOptions::default_instance(),
+ 50003, 8, false, false);
+ ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+ &::google::protobuf::ServiceOptions::default_instance(),
+ 50002, 7, false, false);
+ ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_include_2fPBRPC_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_include_2fPBRPC_2eproto {
+ StaticDescriptorInitializer_include_2fPBRPC_2eproto() {
+ protobuf_AddDesc_include_2fPBRPC_2eproto();
+ }
+} static_descriptor_initializer_include_2fPBRPC_2eproto_;
+
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
+ ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false >
+ proc_id(kProcIdFieldNumber, 0u);
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
+ ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false >
+ data_in(kDataInFieldNumber, false);
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
+ ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false >
+ data_out(kDataOutFieldNumber, false);
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
+ ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false >
+ interface_id(kInterfaceIdFieldNumber, 0u);
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/cpp/generated/include/PBRPC.pb.h b/cpp/generated/include/PBRPC.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..880206c5081c7652d28d931b9522a61aed629671
--- /dev/null
+++ b/cpp/generated/include/PBRPC.pb.h
@@ -0,0 +1,79 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: include/PBRPC.proto
+
+#ifndef PROTOBUF_include_2fPBRPC_2eproto__INCLUDED
+#define PROTOBUF_include_2fPBRPC_2eproto__INCLUDED
+
+#include
+
+#include
+
+#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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
+#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 "google/protobuf/descriptor.pb.h"
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+// Internal implementation detail -- do not call these.
+void protobuf_AddDesc_include_2fPBRPC_2eproto();
+void protobuf_AssignDesc_include_2fPBRPC_2eproto();
+void protobuf_ShutdownFile_include_2fPBRPC_2eproto();
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+static const int kProcIdFieldNumber = 50001;
+extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
+ ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false >
+ proc_id;
+static const int kDataInFieldNumber = 50004;
+extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
+ ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false >
+ data_in;
+static const int kDataOutFieldNumber = 50003;
+extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
+ ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false >
+ data_out;
+static const int kInterfaceIdFieldNumber = 50002;
+extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
+ ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false >
+ interface_id;
+
+// ===================================================================
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+} // namespace google
+} // namespace protobuf
+#endif // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif // PROTOBUF_include_2fPBRPC_2eproto__INCLUDED
diff --git a/cpp/generated/pbrpc/CMakeLists.txt b/cpp/generated/pbrpc/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/cpp/generated/pbrpc/Ping.pb.cc b/cpp/generated/pbrpc/Ping.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9f44e8f7dc1b02516cd2072d2444c4f95b9ac9c7
--- /dev/null
+++ b/cpp/generated/pbrpc/Ping.pb.cc
@@ -0,0 +1,1632 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "pbrpc/Ping.pb.h"
+#include
+#include
+#include
+#include
+#include
+#include
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+namespace {
+
+const ::google::protobuf::Descriptor* PingRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ PingRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PingResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ PingResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PingResponse_PingResult_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ PingResponse_PingResult_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PingResponse_PingError_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ PingResponse_PingError_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Ping_emptyRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ Ping_emptyRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Ping_emptyResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ Ping_emptyResponse_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* PingService_descriptor_ = NULL;
+
+} // namespace
+
+
+void protobuf_AssignDesc_pbrpc_2fPing_2eproto() {
+ protobuf_AddDesc_pbrpc_2fPing_2eproto();
+ const ::google::protobuf::FileDescriptor* file =
+ ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+ "pbrpc/Ping.proto");
+ GOOGLE_CHECK(file != NULL);
+ PingRequest_descriptor_ = file->message_type(0);
+ static const int PingRequest_offsets_[2] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingRequest, text_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingRequest, senderror_),
+ };
+ PingRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ PingRequest_descriptor_,
+ PingRequest::default_instance_,
+ PingRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(PingRequest));
+ PingResponse_descriptor_ = file->message_type(1);
+ static const int PingResponse_offsets_[2] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse, result_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse, error_),
+ };
+ PingResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ PingResponse_descriptor_,
+ PingResponse::default_instance_,
+ PingResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(PingResponse));
+ PingResponse_PingResult_descriptor_ = PingResponse_descriptor_->nested_type(0);
+ static const int PingResponse_PingResult_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingResult, text_),
+ };
+ PingResponse_PingResult_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ PingResponse_PingResult_descriptor_,
+ PingResponse_PingResult::default_instance_,
+ PingResponse_PingResult_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingResult, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingResult, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(PingResponse_PingResult));
+ PingResponse_PingError_descriptor_ = PingResponse_descriptor_->nested_type(1);
+ static const int PingResponse_PingError_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingError, errormessage_),
+ };
+ PingResponse_PingError_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ PingResponse_PingError_descriptor_,
+ PingResponse_PingError::default_instance_,
+ PingResponse_PingError_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingError, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PingResponse_PingError, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(PingResponse_PingError));
+ Ping_emptyRequest_descriptor_ = file->message_type(2);
+ static const int Ping_emptyRequest_offsets_[1] = {
+ };
+ Ping_emptyRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ Ping_emptyRequest_descriptor_,
+ Ping_emptyRequest::default_instance_,
+ Ping_emptyRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ping_emptyRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ping_emptyRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(Ping_emptyRequest));
+ Ping_emptyResponse_descriptor_ = file->message_type(3);
+ static const int Ping_emptyResponse_offsets_[1] = {
+ };
+ Ping_emptyResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ Ping_emptyResponse_descriptor_,
+ Ping_emptyResponse::default_instance_,
+ Ping_emptyResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ping_emptyResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Ping_emptyResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(Ping_emptyResponse));
+ PingService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+ ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+ &protobuf_AssignDesc_pbrpc_2fPing_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ PingRequest_descriptor_, &PingRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ PingResponse_descriptor_, &PingResponse::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ PingResponse_PingResult_descriptor_, &PingResponse_PingResult::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ PingResponse_PingError_descriptor_, &PingResponse_PingError::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ Ping_emptyRequest_descriptor_, &Ping_emptyRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ Ping_emptyResponse_descriptor_, &Ping_emptyResponse::default_instance());
+}
+
+} // namespace
+
+void protobuf_ShutdownFile_pbrpc_2fPing_2eproto() {
+ delete PingRequest::default_instance_;
+ delete PingRequest_reflection_;
+ delete PingResponse::default_instance_;
+ delete PingResponse_reflection_;
+ delete PingResponse_PingResult::default_instance_;
+ delete PingResponse_PingResult_reflection_;
+ delete PingResponse_PingError::default_instance_;
+ delete PingResponse_PingError_reflection_;
+ delete Ping_emptyRequest::default_instance_;
+ delete Ping_emptyRequest_reflection_;
+ delete Ping_emptyResponse::default_instance_;
+ delete Ping_emptyResponse_reflection_;
+}
+
+void protobuf_AddDesc_pbrpc_2fPing_2eproto() {
+ static bool already_here = false;
+ if (already_here) return;
+ already_here = true;
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fPBRPC_2eproto();
+ ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+ "\n\020pbrpc/Ping.proto\022\016xtreemfs.pbrpc\032\023incl"
+ "ude/PBRPC.proto\".\n\013PingRequest\022\014\n\004text\030\001"
+ " \002(\t\022\021\n\tsendError\030\002 \002(\010\"\275\001\n\014PingResponse"
+ "\0227\n\006result\030\001 \001(\0132\'.xtreemfs.pbrpc.PingRe"
+ "sponse.PingResult\0225\n\005error\030\002 \001(\0132&.xtree"
+ "mfs.pbrpc.PingResponse.PingError\032\032\n\nPing"
+ "Result\022\014\n\004text\030\001 \002(\t\032!\n\tPingError\022\024\n\014err"
+ "orMessage\030\001 \002(\t\"\023\n\021Ping_emptyRequest\"\024\n\022"
+ "Ping_emptyResponse2\305\001\n\013PingService\022P\n\006do"
+ "Ping\022\033.xtreemfs.pbrpc.PingRequest\032\034.xtre"
+ "emfs.pbrpc.PingResponse\"\013\215\265\030\001\000\000\000\240\265\030\001\022[\n\t"
+ "emptyPing\022!.xtreemfs.pbrpc.Ping_emptyReq"
+ "uest\032\".xtreemfs.pbrpc.Ping_emptyResponse"
+ "\"\007\215\265\030\002\000\000\000\032\007\225\265\030\001\000\000\000B3\n1org.xtreemfs.found"
+ "ation.pbrpc.generatedinterfaces", 591);
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+ "pbrpc/Ping.proto", &protobuf_RegisterTypes);
+ PingRequest::default_instance_ = new PingRequest();
+ PingResponse::default_instance_ = new PingResponse();
+ PingResponse_PingResult::default_instance_ = new PingResponse_PingResult();
+ PingResponse_PingError::default_instance_ = new PingResponse_PingError();
+ Ping_emptyRequest::default_instance_ = new Ping_emptyRequest();
+ Ping_emptyResponse::default_instance_ = new Ping_emptyResponse();
+ PingRequest::default_instance_->InitAsDefaultInstance();
+ PingResponse::default_instance_->InitAsDefaultInstance();
+ PingResponse_PingResult::default_instance_->InitAsDefaultInstance();
+ PingResponse_PingError::default_instance_->InitAsDefaultInstance();
+ Ping_emptyRequest::default_instance_->InitAsDefaultInstance();
+ Ping_emptyResponse::default_instance_->InitAsDefaultInstance();
+ ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pbrpc_2fPing_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_pbrpc_2fPing_2eproto {
+ StaticDescriptorInitializer_pbrpc_2fPing_2eproto() {
+ protobuf_AddDesc_pbrpc_2fPing_2eproto();
+ }
+} static_descriptor_initializer_pbrpc_2fPing_2eproto_;
+
+
+// ===================================================================
+
+const ::std::string PingRequest::_default_text_;
+#ifndef _MSC_VER
+const int PingRequest::kTextFieldNumber;
+const int PingRequest::kSendErrorFieldNumber;
+#endif // !_MSC_VER
+
+PingRequest::PingRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void PingRequest::InitAsDefaultInstance() {
+}
+
+PingRequest::PingRequest(const PingRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void PingRequest::SharedCtor() {
+ _cached_size_ = 0;
+ text_ = const_cast< ::std::string*>(&_default_text_);
+ senderror_ = false;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PingRequest::~PingRequest() {
+ SharedDtor();
+}
+
+void PingRequest::SharedDtor() {
+ if (text_ != &_default_text_) {
+ delete text_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void PingRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PingRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return PingRequest_descriptor_;
+}
+
+const PingRequest& PingRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+}
+
+PingRequest* PingRequest::default_instance_ = NULL;
+
+PingRequest* PingRequest::New() const {
+ return new PingRequest;
+}
+
+void PingRequest::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (text_ != &_default_text_) {
+ text_->clear();
+ }
+ }
+ senderror_ = false;
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool PingRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string text = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_text()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->text().data(), this->text().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(16)) goto parse_sendError;
+ break;
+ }
+
+ // required bool sendError = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ parse_sendError:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+ input, &senderror_)));
+ _set_bit(1);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void PingRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string text = 1;
+ if (_has_bit(0)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->senderror(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* PingRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string text = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->text().data(), this->text().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->text(), target);
+ }
+
+ // required bool sendError = 2;
+ if (_has_bit(1)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->senderror(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int PingRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string text = 1;
+ if (has_text()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->text());
+ }
+
+ // required bool sendError = 2;
+ if (has_senderror()) {
+ total_size += 1 + 1;
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void PingRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const PingRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void PingRequest::MergeFrom(const PingRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_text(from.text());
+ }
+ if (from._has_bit(1)) {
+ set_senderror(from.senderror());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PingRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void PingRequest::CopyFrom(const PingRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool PingRequest::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+ return true;
+}
+
+void PingRequest::Swap(PingRequest* other) {
+ if (other != this) {
+ std::swap(text_, other->text_);
+ std::swap(senderror_, other->senderror_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata PingRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = PingRequest_descriptor_;
+ metadata.reflection = PingRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string PingResponse_PingResult::_default_text_;
+#ifndef _MSC_VER
+const int PingResponse_PingResult::kTextFieldNumber;
+#endif // !_MSC_VER
+
+PingResponse_PingResult::PingResponse_PingResult()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void PingResponse_PingResult::InitAsDefaultInstance() {
+}
+
+PingResponse_PingResult::PingResponse_PingResult(const PingResponse_PingResult& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void PingResponse_PingResult::SharedCtor() {
+ _cached_size_ = 0;
+ text_ = const_cast< ::std::string*>(&_default_text_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PingResponse_PingResult::~PingResponse_PingResult() {
+ SharedDtor();
+}
+
+void PingResponse_PingResult::SharedDtor() {
+ if (text_ != &_default_text_) {
+ delete text_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void PingResponse_PingResult::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PingResponse_PingResult::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return PingResponse_PingResult_descriptor_;
+}
+
+const PingResponse_PingResult& PingResponse_PingResult::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+}
+
+PingResponse_PingResult* PingResponse_PingResult::default_instance_ = NULL;
+
+PingResponse_PingResult* PingResponse_PingResult::New() const {
+ return new PingResponse_PingResult;
+}
+
+void PingResponse_PingResult::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (text_ != &_default_text_) {
+ text_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool PingResponse_PingResult::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string text = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_text()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->text().data(), this->text().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void PingResponse_PingResult::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string text = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->text().data(), this->text().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->text(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* PingResponse_PingResult::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string text = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->text().data(), this->text().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->text(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int PingResponse_PingResult::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string text = 1;
+ if (has_text()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->text());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void PingResponse_PingResult::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const PingResponse_PingResult* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void PingResponse_PingResult::MergeFrom(const PingResponse_PingResult& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_text(from.text());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PingResponse_PingResult::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void PingResponse_PingResult::CopyFrom(const PingResponse_PingResult& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool PingResponse_PingResult::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void PingResponse_PingResult::Swap(PingResponse_PingResult* other) {
+ if (other != this) {
+ std::swap(text_, other->text_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata PingResponse_PingResult::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = PingResponse_PingResult_descriptor_;
+ metadata.reflection = PingResponse_PingResult_reflection_;
+ return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+const ::std::string PingResponse_PingError::_default_errormessage_;
+#ifndef _MSC_VER
+const int PingResponse_PingError::kErrorMessageFieldNumber;
+#endif // !_MSC_VER
+
+PingResponse_PingError::PingResponse_PingError()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void PingResponse_PingError::InitAsDefaultInstance() {
+}
+
+PingResponse_PingError::PingResponse_PingError(const PingResponse_PingError& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void PingResponse_PingError::SharedCtor() {
+ _cached_size_ = 0;
+ errormessage_ = const_cast< ::std::string*>(&_default_errormessage_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PingResponse_PingError::~PingResponse_PingError() {
+ SharedDtor();
+}
+
+void PingResponse_PingError::SharedDtor() {
+ if (errormessage_ != &_default_errormessage_) {
+ delete errormessage_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void PingResponse_PingError::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PingResponse_PingError::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return PingResponse_PingError_descriptor_;
+}
+
+const PingResponse_PingError& PingResponse_PingError::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+}
+
+PingResponse_PingError* PingResponse_PingError::default_instance_ = NULL;
+
+PingResponse_PingError* PingResponse_PingError::New() const {
+ return new PingResponse_PingError;
+}
+
+void PingResponse_PingError::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (errormessage_ != &_default_errormessage_) {
+ errormessage_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool PingResponse_PingError::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string errorMessage = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_errormessage()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->errormessage().data(), this->errormessage().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void PingResponse_PingError::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string errorMessage = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->errormessage().data(), this->errormessage().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->errormessage(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* PingResponse_PingError::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string errorMessage = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->errormessage().data(), this->errormessage().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->errormessage(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int PingResponse_PingError::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string errorMessage = 1;
+ if (has_errormessage()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->errormessage());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void PingResponse_PingError::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const PingResponse_PingError* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void PingResponse_PingError::MergeFrom(const PingResponse_PingError& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_errormessage(from.errormessage());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PingResponse_PingError::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void PingResponse_PingError::CopyFrom(const PingResponse_PingError& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool PingResponse_PingError::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void PingResponse_PingError::Swap(PingResponse_PingError* other) {
+ if (other != this) {
+ std::swap(errormessage_, other->errormessage_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata PingResponse_PingError::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = PingResponse_PingError_descriptor_;
+ metadata.reflection = PingResponse_PingError_reflection_;
+ return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int PingResponse::kResultFieldNumber;
+const int PingResponse::kErrorFieldNumber;
+#endif // !_MSC_VER
+
+PingResponse::PingResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void PingResponse::InitAsDefaultInstance() {
+ result_ = const_cast< ::xtreemfs::pbrpc::PingResponse_PingResult*>(&::xtreemfs::pbrpc::PingResponse_PingResult::default_instance());
+ error_ = const_cast< ::xtreemfs::pbrpc::PingResponse_PingError*>(&::xtreemfs::pbrpc::PingResponse_PingError::default_instance());
+}
+
+PingResponse::PingResponse(const PingResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void PingResponse::SharedCtor() {
+ _cached_size_ = 0;
+ result_ = NULL;
+ error_ = NULL;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PingResponse::~PingResponse() {
+ SharedDtor();
+}
+
+void PingResponse::SharedDtor() {
+ if (this != default_instance_) {
+ delete result_;
+ delete error_;
+ }
+}
+
+void PingResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PingResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return PingResponse_descriptor_;
+}
+
+const PingResponse& PingResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+}
+
+PingResponse* PingResponse::default_instance_ = NULL;
+
+PingResponse* PingResponse::New() const {
+ return new PingResponse;
+}
+
+void PingResponse::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (result_ != NULL) result_->::xtreemfs::pbrpc::PingResponse_PingResult::Clear();
+ }
+ if (_has_bit(1)) {
+ if (error_ != NULL) error_->::xtreemfs::pbrpc::PingResponse_PingError::Clear();
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool PingResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_result()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(18)) goto parse_error;
+ break;
+ }
+
+ // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_error:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_error()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void PingResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 1, this->result(), output);
+ }
+
+ // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2;
+ if (_has_bit(1)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 2, this->error(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* PingResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 1, this->result(), target);
+ }
+
+ // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2;
+ if (_has_bit(1)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 2, this->error(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int PingResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
+ if (has_result()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->result());
+ }
+
+ // optional .xtreemfs.pbrpc.PingResponse.PingError error = 2;
+ if (has_error()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->error());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void PingResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const PingResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void PingResponse::MergeFrom(const PingResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ mutable_result()->::xtreemfs::pbrpc::PingResponse_PingResult::MergeFrom(from.result());
+ }
+ if (from._has_bit(1)) {
+ mutable_error()->::xtreemfs::pbrpc::PingResponse_PingError::MergeFrom(from.error());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PingResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void PingResponse::CopyFrom(const PingResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool PingResponse::IsInitialized() const {
+
+ if (has_result()) {
+ if (!this->result().IsInitialized()) return false;
+ }
+ if (has_error()) {
+ if (!this->error().IsInitialized()) return false;
+ }
+ return true;
+}
+
+void PingResponse::Swap(PingResponse* other) {
+ if (other != this) {
+ std::swap(result_, other->result_);
+ std::swap(error_, other->error_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata PingResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = PingResponse_descriptor_;
+ metadata.reflection = PingResponse_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif // !_MSC_VER
+
+Ping_emptyRequest::Ping_emptyRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void Ping_emptyRequest::InitAsDefaultInstance() {
+}
+
+Ping_emptyRequest::Ping_emptyRequest(const Ping_emptyRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void Ping_emptyRequest::SharedCtor() {
+ _cached_size_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Ping_emptyRequest::~Ping_emptyRequest() {
+ SharedDtor();
+}
+
+void Ping_emptyRequest::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void Ping_emptyRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Ping_emptyRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return Ping_emptyRequest_descriptor_;
+}
+
+const Ping_emptyRequest& Ping_emptyRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+}
+
+Ping_emptyRequest* Ping_emptyRequest::default_instance_ = NULL;
+
+Ping_emptyRequest* Ping_emptyRequest::New() const {
+ return new Ping_emptyRequest;
+}
+
+void Ping_emptyRequest::Clear() {
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool Ping_emptyRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ }
+ return true;
+#undef DO_
+}
+
+void Ping_emptyRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* Ping_emptyRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int Ping_emptyRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void Ping_emptyRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const Ping_emptyRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void Ping_emptyRequest::MergeFrom(const Ping_emptyRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Ping_emptyRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Ping_emptyRequest::CopyFrom(const Ping_emptyRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Ping_emptyRequest::IsInitialized() const {
+
+ return true;
+}
+
+void Ping_emptyRequest::Swap(Ping_emptyRequest* other) {
+ if (other != this) {
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata Ping_emptyRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = Ping_emptyRequest_descriptor_;
+ metadata.reflection = Ping_emptyRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif // !_MSC_VER
+
+Ping_emptyResponse::Ping_emptyResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void Ping_emptyResponse::InitAsDefaultInstance() {
+}
+
+Ping_emptyResponse::Ping_emptyResponse(const Ping_emptyResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void Ping_emptyResponse::SharedCtor() {
+ _cached_size_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Ping_emptyResponse::~Ping_emptyResponse() {
+ SharedDtor();
+}
+
+void Ping_emptyResponse::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void Ping_emptyResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Ping_emptyResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return Ping_emptyResponse_descriptor_;
+}
+
+const Ping_emptyResponse& Ping_emptyResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fPing_2eproto(); return *default_instance_;
+}
+
+Ping_emptyResponse* Ping_emptyResponse::default_instance_ = NULL;
+
+Ping_emptyResponse* Ping_emptyResponse::New() const {
+ return new Ping_emptyResponse;
+}
+
+void Ping_emptyResponse::Clear() {
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool Ping_emptyResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ }
+ return true;
+#undef DO_
+}
+
+void Ping_emptyResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* Ping_emptyResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int Ping_emptyResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void Ping_emptyResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const Ping_emptyResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void Ping_emptyResponse::MergeFrom(const Ping_emptyResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Ping_emptyResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Ping_emptyResponse::CopyFrom(const Ping_emptyResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Ping_emptyResponse::IsInitialized() const {
+
+ return true;
+}
+
+void Ping_emptyResponse::Swap(Ping_emptyResponse* other) {
+ if (other != this) {
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata Ping_emptyResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = Ping_emptyResponse_descriptor_;
+ metadata.reflection = Ping_emptyResponse_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+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
+} // namespace xtreemfs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/cpp/generated/pbrpc/Ping.pb.h b/cpp/generated/pbrpc/Ping.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0f02e7da923016892aa6f626fab4872ab1693e2
--- /dev/null
+++ b/cpp/generated/pbrpc/Ping.pb.h
@@ -0,0 +1,881 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: pbrpc/Ping.proto
+
+#ifndef PROTOBUF_pbrpc_2fPing_2eproto__INCLUDED
+#define PROTOBUF_pbrpc_2fPing_2eproto__INCLUDED
+
+#include
+
+#include
+
+#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include
+#include
+#include
+#include
+#include
+#include "include/PBRPC.pb.h"
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+// Internal implementation detail -- do not call these.
+void protobuf_AddDesc_pbrpc_2fPing_2eproto();
+void protobuf_AssignDesc_pbrpc_2fPing_2eproto();
+void protobuf_ShutdownFile_pbrpc_2fPing_2eproto();
+
+class PingRequest;
+class PingResponse;
+class PingResponse_PingResult;
+class PingResponse_PingError;
+class Ping_emptyRequest;
+class Ping_emptyResponse;
+
+// ===================================================================
+
+class PingRequest : public ::google::protobuf::Message {
+ public:
+ PingRequest();
+ virtual ~PingRequest();
+
+ PingRequest(const PingRequest& from);
+
+ inline PingRequest& operator=(const PingRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const PingRequest& default_instance();
+
+ void Swap(PingRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ PingRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const PingRequest& from);
+ void MergeFrom(const PingRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string text = 1;
+ inline bool has_text() const;
+ inline void clear_text();
+ static const int kTextFieldNumber = 1;
+ inline const ::std::string& text() const;
+ inline void set_text(const ::std::string& value);
+ inline void set_text(const char* value);
+ inline void set_text(const char* value, size_t size);
+ inline ::std::string* mutable_text();
+
+ // 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:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* text_;
+ static const ::std::string _default_text_;
+ bool senderror_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class PingResponse_PingResult : public ::google::protobuf::Message {
+ public:
+ PingResponse_PingResult();
+ virtual ~PingResponse_PingResult();
+
+ PingResponse_PingResult(const PingResponse_PingResult& from);
+
+ inline PingResponse_PingResult& operator=(const PingResponse_PingResult& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const PingResponse_PingResult& default_instance();
+
+ void Swap(PingResponse_PingResult* other);
+
+ // implements Message ----------------------------------------------
+
+ PingResponse_PingResult* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const PingResponse_PingResult& from);
+ void MergeFrom(const PingResponse_PingResult& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string text = 1;
+ inline bool has_text() const;
+ inline void clear_text();
+ static const int kTextFieldNumber = 1;
+ inline const ::std::string& text() const;
+ inline void set_text(const ::std::string& value);
+ inline void set_text(const char* value);
+ inline void set_text(const char* value, size_t size);
+ inline ::std::string* mutable_text();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.PingResponse.PingResult)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* text_;
+ static const ::std::string _default_text_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class PingResponse_PingError : public ::google::protobuf::Message {
+ public:
+ PingResponse_PingError();
+ virtual ~PingResponse_PingError();
+
+ PingResponse_PingError(const PingResponse_PingError& from);
+
+ inline PingResponse_PingError& operator=(const PingResponse_PingError& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const PingResponse_PingError& default_instance();
+
+ void Swap(PingResponse_PingError* other);
+
+ // implements Message ----------------------------------------------
+
+ PingResponse_PingError* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const PingResponse_PingError& from);
+ void MergeFrom(const PingResponse_PingError& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string errorMessage = 1;
+ inline bool has_errormessage() const;
+ inline void clear_errormessage();
+ static const int kErrorMessageFieldNumber = 1;
+ inline const ::std::string& errormessage() const;
+ inline void set_errormessage(const ::std::string& value);
+ inline void set_errormessage(const char* value);
+ inline void set_errormessage(const char* value, size_t size);
+ inline ::std::string* mutable_errormessage();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.PingResponse.PingError)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* errormessage_;
+ static const ::std::string _default_errormessage_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class PingResponse : public ::google::protobuf::Message {
+ public:
+ PingResponse();
+ virtual ~PingResponse();
+
+ PingResponse(const PingResponse& from);
+
+ inline PingResponse& operator=(const PingResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const PingResponse& default_instance();
+
+ void Swap(PingResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ PingResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const PingResponse& from);
+ void MergeFrom(const PingResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ typedef PingResponse_PingResult PingResult;
+ typedef PingResponse_PingError PingError;
+
+ // accessors -------------------------------------------------------
+
+ // optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
+ inline bool has_result() const;
+ inline void clear_result();
+ static const int kResultFieldNumber = 1;
+ inline const ::xtreemfs::pbrpc::PingResponse_PingResult& result() const;
+ inline ::xtreemfs::pbrpc::PingResponse_PingResult* mutable_result();
+
+ // 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();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.PingResponse)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::xtreemfs::pbrpc::PingResponse_PingResult* result_;
+ ::xtreemfs::pbrpc::PingResponse_PingError* error_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class Ping_emptyRequest : public ::google::protobuf::Message {
+ public:
+ Ping_emptyRequest();
+ virtual ~Ping_emptyRequest();
+
+ Ping_emptyRequest(const Ping_emptyRequest& from);
+
+ inline Ping_emptyRequest& operator=(const Ping_emptyRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const Ping_emptyRequest& default_instance();
+
+ void Swap(Ping_emptyRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ Ping_emptyRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const Ping_emptyRequest& from);
+ void MergeFrom(const Ping_emptyRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Ping_emptyRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class Ping_emptyResponse : public ::google::protobuf::Message {
+ public:
+ Ping_emptyResponse();
+ virtual ~Ping_emptyResponse();
+
+ Ping_emptyResponse(const Ping_emptyResponse& from);
+
+ inline Ping_emptyResponse& operator=(const Ping_emptyResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const Ping_emptyResponse& default_instance();
+
+ void Swap(Ping_emptyResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ Ping_emptyResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const Ping_emptyResponse& from);
+ void MergeFrom(const Ping_emptyResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Ping_emptyResponse)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ 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);
+};
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// PingRequest
+
+// required string text = 1;
+inline bool PingRequest::has_text() const {
+ return _has_bit(0);
+}
+inline void PingRequest::clear_text() {
+ if (text_ != &_default_text_) {
+ text_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ text_ = new ::std::string;
+ }
+ text_->assign(value);
+}
+inline void PingRequest::set_text(const char* value) {
+ _set_bit(0);
+ if (text_ == &_default_text_) {
+ 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_) {
+ text_ = new ::std::string;
+ }
+ text_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* PingRequest::mutable_text() {
+ _set_bit(0);
+ if (text_ == &_default_text_) {
+ text_ = new ::std::string;
+ }
+ return text_;
+}
+
+// required bool sendError = 2;
+inline bool PingRequest::has_senderror() const {
+ return _has_bit(1);
+}
+inline void PingRequest::clear_senderror() {
+ senderror_ = false;
+ _clear_bit(1);
+}
+inline bool PingRequest::senderror() const {
+ return senderror_;
+}
+inline void PingRequest::set_senderror(bool value) {
+ _set_bit(1);
+ senderror_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// PingResponse_PingResult
+
+// required string text = 1;
+inline bool PingResponse_PingResult::has_text() const {
+ return _has_bit(0);
+}
+inline void PingResponse_PingResult::clear_text() {
+ if (text_ != &_default_text_) {
+ text_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ text_ = new ::std::string;
+ }
+ text_->assign(value);
+}
+inline void PingResponse_PingResult::set_text(const char* value) {
+ _set_bit(0);
+ if (text_ == &_default_text_) {
+ 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_) {
+ text_ = new ::std::string;
+ }
+ text_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* PingResponse_PingResult::mutable_text() {
+ _set_bit(0);
+ if (text_ == &_default_text_) {
+ text_ = new ::std::string;
+ }
+ return text_;
+}
+
+// -------------------------------------------------------------------
+
+// PingResponse_PingError
+
+// required string errorMessage = 1;
+inline bool PingResponse_PingError::has_errormessage() const {
+ return _has_bit(0);
+}
+inline void PingResponse_PingError::clear_errormessage() {
+ if (errormessage_ != &_default_errormessage_) {
+ errormessage_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ errormessage_ = new ::std::string;
+ }
+ errormessage_->assign(value);
+}
+inline void PingResponse_PingError::set_errormessage(const char* value) {
+ _set_bit(0);
+ if (errormessage_ == &_default_errormessage_) {
+ 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_) {
+ errormessage_ = new ::std::string;
+ }
+ errormessage_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* PingResponse_PingError::mutable_errormessage() {
+ _set_bit(0);
+ if (errormessage_ == &_default_errormessage_) {
+ errormessage_ = new ::std::string;
+ }
+ return errormessage_;
+}
+
+// -------------------------------------------------------------------
+
+// PingResponse
+
+// optional .xtreemfs.pbrpc.PingResponse.PingResult result = 1;
+inline bool PingResponse::has_result() const {
+ return _has_bit(0);
+}
+inline void PingResponse::clear_result() {
+ if (result_ != NULL) result_->::xtreemfs::pbrpc::PingResponse_PingResult::Clear();
+ _clear_bit(0);
+}
+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);
+ if (result_ == NULL) result_ = new ::xtreemfs::pbrpc::PingResponse_PingResult;
+ return result_;
+}
+
+// optional .xtreemfs.pbrpc.PingResponse.PingError error = 2;
+inline bool PingResponse::has_error() const {
+ return _has_bit(1);
+}
+inline void PingResponse::clear_error() {
+ if (error_ != NULL) error_->::xtreemfs::pbrpc::PingResponse_PingError::Clear();
+ _clear_bit(1);
+}
+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);
+ if (error_ == NULL) error_ = new ::xtreemfs::pbrpc::PingResponse_PingError;
+ return error_;
+}
+
+// -------------------------------------------------------------------
+
+// Ping_emptyRequest
+
+// -------------------------------------------------------------------
+
+// Ping_emptyResponse
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+} // namespace google
+} // namespace protobuf
+#endif // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif // PROTOBUF_pbrpc_2fPing_2eproto__INCLUDED
diff --git a/cpp/generated/pbrpc/PingServiceClient.h b/cpp/generated/pbrpc/PingServiceClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a1fb042a0f2889ef382c519d217c2dda18f2d11
--- /dev/null
+++ b/cpp/generated/pbrpc/PingServiceClient.h
@@ -0,0 +1,79 @@
+//automatically generated from Ping.proto at Fri Jul 22 16:47:13 CEST 2011
+//(c) 2011. See LICENSE file for details.
+
+#ifndef PINGSERVICECLIENT_H
+#define PINGSERVICECLIENT_H
+
+#include
+#include "pbrpc/RPC.pb.h"
+#include "rpc/client.h"
+#include "rpc/sync_callback.h"
+#include "rpc/callback_interface.h"
+#include "pbrpc/Ping.pb.h"
+
+
+namespace xtreemfs {
+ namespace pbrpc {
+ using ::xtreemfs::rpc::Client;
+ using ::xtreemfs::rpc::CallbackInterface;
+ using ::xtreemfs::rpc::SyncCallback;
+
+ class PingServiceClient {
+
+ public:
+ PingServiceClient(Client* client) : client_(client) {
+ }
+
+ virtual ~PingServiceClient() {
+ }
+
+ void doPing(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::PingRequest* request,const char* data, boost::uint32_t data_length,
+ CallbackInterface *callback, void *context = NULL) {
+ client_->sendRequest(address, 1, 1,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::PingResponse(),
+ context, callback);
+ }
+
+ SyncCallback* doPing_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::PingRequest* request, const char* data, boost::uint32_t data_length) {
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 1, 1,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::PingResponse(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void emptyPing(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::Ping_emptyRequest* request = NULL;
+ client_->sendRequest(address, 1, 2,
+ creds, auth, request, data, data_length, NULL,
+ context, callback);
+ }
+
+ SyncCallback* emptyPing_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::Ping_emptyRequest* request = NULL;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 1, 2,
+ creds, auth, request, data, data_length, NULL,
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ private:
+ Client* client_;
+ };
+ }
+}
+#endif //PINGSERVICECLIENT_H
diff --git a/cpp/generated/pbrpc/RPC.pb.cc b/cpp/generated/pbrpc/RPC.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5582a5c3e554ef354d18a3cdf5cb4036ab2228b4
--- /dev/null
+++ b/cpp/generated/pbrpc/RPC.pb.cc
@@ -0,0 +1,2282 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "pbrpc/RPC.pb.h"
+#include
+#include
+#include
+#include
+#include
+#include
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+namespace {
+
+const ::google::protobuf::Descriptor* UserCredentials_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ UserCredentials_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AuthPassword_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ AuthPassword_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Auth_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ Auth_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RPCHeader_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ RPCHeader_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RPCHeader_RequestHeader_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ RPCHeader_RequestHeader_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RPCHeader_ErrorResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ RPCHeader_ErrorResponse_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* MessageType_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* AuthType_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* ErrorType_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor_ = NULL;
+
+} // namespace
+
+
+void protobuf_AssignDesc_pbrpc_2fRPC_2eproto() {
+ protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+ const ::google::protobuf::FileDescriptor* file =
+ ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+ "pbrpc/RPC.proto");
+ GOOGLE_CHECK(file != NULL);
+ UserCredentials_descriptor_ = file->message_type(0);
+ static const int UserCredentials_offsets_[2] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, username_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, groups_),
+ };
+ UserCredentials_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ UserCredentials_descriptor_,
+ UserCredentials::default_instance_,
+ UserCredentials_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(UserCredentials));
+ AuthPassword_descriptor_ = file->message_type(1);
+ static const int AuthPassword_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, password_),
+ };
+ AuthPassword_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ AuthPassword_descriptor_,
+ AuthPassword::default_instance_,
+ AuthPassword_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(AuthPassword));
+ Auth_descriptor_ = file->message_type(2);
+ static const int Auth_offsets_[3] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_type_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_passwd_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_data_),
+ };
+ Auth_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ Auth_descriptor_,
+ Auth::default_instance_,
+ Auth_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(Auth));
+ RPCHeader_descriptor_ = file->message_type(3);
+ static const int RPCHeader_offsets_[4] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, call_id_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, message_type_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, request_header_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, error_response_),
+ };
+ RPCHeader_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ RPCHeader_descriptor_,
+ RPCHeader::default_instance_,
+ RPCHeader_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(RPCHeader));
+ RPCHeader_RequestHeader_descriptor_ = RPCHeader_descriptor_->nested_type(0);
+ static const int RPCHeader_RequestHeader_offsets_[4] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, interface_id_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, proc_id_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, user_creds_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, auth_data_),
+ };
+ RPCHeader_RequestHeader_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ RPCHeader_RequestHeader_descriptor_,
+ RPCHeader_RequestHeader::default_instance_,
+ RPCHeader_RequestHeader_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(RPCHeader_RequestHeader));
+ RPCHeader_ErrorResponse_descriptor_ = RPCHeader_descriptor_->nested_type(1);
+ static const int RPCHeader_ErrorResponse_offsets_[5] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, error_type_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, posix_errno_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, error_message_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, debug_info_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, redirect_to_server_uuid_),
+ };
+ RPCHeader_ErrorResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ RPCHeader_ErrorResponse_descriptor_,
+ RPCHeader_ErrorResponse::default_instance_,
+ RPCHeader_ErrorResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(RPCHeader_ErrorResponse));
+ MessageType_descriptor_ = file->enum_type(0);
+ AuthType_descriptor_ = file->enum_type(1);
+ ErrorType_descriptor_ = file->enum_type(2);
+ POSIXErrno_descriptor_ = file->enum_type(3);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+ ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+ &protobuf_AssignDesc_pbrpc_2fRPC_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ UserCredentials_descriptor_, &UserCredentials::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ AuthPassword_descriptor_, &AuthPassword::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ Auth_descriptor_, &Auth::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ RPCHeader_descriptor_, &RPCHeader::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ RPCHeader_RequestHeader_descriptor_, &RPCHeader_RequestHeader::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ RPCHeader_ErrorResponse_descriptor_, &RPCHeader_ErrorResponse::default_instance());
+}
+
+} // namespace
+
+void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto() {
+ delete UserCredentials::default_instance_;
+ delete UserCredentials_reflection_;
+ delete AuthPassword::default_instance_;
+ delete AuthPassword_reflection_;
+ delete Auth::default_instance_;
+ delete Auth_reflection_;
+ delete RPCHeader::default_instance_;
+ delete RPCHeader_reflection_;
+ delete RPCHeader_RequestHeader::default_instance_;
+ delete RPCHeader_RequestHeader_reflection_;
+ delete RPCHeader_ErrorResponse::default_instance_;
+ delete RPCHeader_ErrorResponse_reflection_;
+}
+
+void protobuf_AddDesc_pbrpc_2fRPC_2eproto() {
+ static bool already_here = false;
+ if (already_here) return;
+ already_here = true;
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+ "\n\017pbrpc/RPC.proto\022\016xtreemfs.pbrpc\"3\n\017Use"
+ "rCredentials\022\020\n\010username\030\001 \002(\t\022\016\n\006groups"
+ "\030\002 \003(\t\" \n\014AuthPassword\022\020\n\010password\030\001 \002(\t"
+ "\"y\n\004Auth\022+\n\tauth_type\030\001 \002(\0162\030.xtreemfs.p"
+ "brpc.AuthType\0221\n\013auth_passwd\030\003 \001(\0132\034.xtr"
+ "eemfs.pbrpc.AuthPassword\022\021\n\tauth_data\030\002 "
+ "\001(\014\"\270\004\n\tRPCHeader\022\017\n\007call_id\030\001 \002(\007\0221\n\014me"
+ "ssage_type\030\002 \002(\0162\033.xtreemfs.pbrpc.Messag"
+ "eType\022?\n\016request_header\030\003 \001(\0132\'.xtreemfs"
+ ".pbrpc.RPCHeader.RequestHeader\022?\n\016error_"
+ "response\030\004 \001(\0132\'.xtreemfs.pbrpc.RPCHeade"
+ "r.ErrorResponse\032\224\001\n\rRequestHeader\022\024\n\014int"
+ "erface_id\030\001 \002(\007\022\017\n\007proc_id\030\002 \002(\007\0223\n\nuser"
+ "_creds\030\003 \002(\0132\037.xtreemfs.pbrpc.UserCreden"
+ "tials\022\'\n\tauth_data\030\004 \002(\0132\024.xtreemfs.pbrp"
+ "c.Auth\032\315\001\n\rErrorResponse\022-\n\nerror_type\030\001"
+ " \002(\0162\031.xtreemfs.pbrpc.ErrorType\022A\n\013posix"
+ "_errno\030\002 \001(\0162\032.xtreemfs.pbrpc.POSIXErrno"
+ ":\020POSIX_ERROR_NONE\022\025\n\rerror_message\030\003 \001("
+ "\t\022\022\n\ndebug_info\030\004 \001(\t\022\037\n\027redirect_to_ser"
+ "ver_uuid\030\005 \001(\t*P\n\013MessageType\022\017\n\013RPC_REQ"
+ "UEST\020\000\022\030\n\024RPC_RESPONSE_SUCCESS\020\001\022\026\n\022RPC_"
+ "RESPONSE_ERROR\020\002*,\n\010AuthType\022\r\n\tAUTH_NON"
+ "E\020\000\022\021\n\rAUTH_PASSWORD\020\001*\237\001\n\tErrorType\022\030\n\024"
+ "INVALID_INTERFACE_ID\020\001\022\023\n\017INVALID_PROC_I"
+ "D\020\002\022\020\n\014GARBAGE_ARGS\020\003\022\017\n\013AUTH_FAILED\020\004\022\031"
+ "\n\025INTERNAL_SERVER_ERROR\020\005\022\t\n\005ERRNO\020\006\022\014\n\010"
+ "REDIRECT\020\007\022\014\n\010IO_ERROR\020d*\333\002\n\nPOSIXErrno\022"
+ "\025\n\020POSIX_ERROR_NONE\020\217N\022\025\n\021POSIX_ERROR_EP"
+ "ERM\020\001\022\026\n\022POSIX_ERROR_ENOENT\020\002\022\023\n\017POSIX_E"
+ "RROR_EIO\020\005\022\026\n\022POSIX_ERROR_EAGAIN\020\013\022\026\n\022PO"
+ "SIX_ERROR_EACCES\020\r\022\026\n\022POSIX_ERROR_EEXIST"
+ "\020\021\022\025\n\021POSIX_ERROR_EXDEV\020\022\022\026\n\022POSIX_ERROR"
+ "_ENODEV\020\023\022\027\n\023POSIX_ERROR_ENOTDIR\020\024\022\026\n\022PO"
+ "SIX_ERROR_EISDIR\020\025\022\026\n\022POSIX_ERROR_EINVAL"
+ "\020\026\022\031\n\025POSIX_ERROR_ENOTEMPTY\020\'\022\027\n\023POSIX_E"
+ "RROR_ENODATA\020=B3\n1org.xtreemfs.foundatio"
+ "n.pbrpc.generatedinterfaces", 1507);
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+ "pbrpc/RPC.proto", &protobuf_RegisterTypes);
+ UserCredentials::default_instance_ = new UserCredentials();
+ AuthPassword::default_instance_ = new AuthPassword();
+ Auth::default_instance_ = new Auth();
+ RPCHeader::default_instance_ = new RPCHeader();
+ RPCHeader_RequestHeader::default_instance_ = new RPCHeader_RequestHeader();
+ RPCHeader_ErrorResponse::default_instance_ = new RPCHeader_ErrorResponse();
+ UserCredentials::default_instance_->InitAsDefaultInstance();
+ AuthPassword::default_instance_->InitAsDefaultInstance();
+ Auth::default_instance_->InitAsDefaultInstance();
+ RPCHeader::default_instance_->InitAsDefaultInstance();
+ RPCHeader_RequestHeader::default_instance_->InitAsDefaultInstance();
+ RPCHeader_ErrorResponse::default_instance_->InitAsDefaultInstance();
+ ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pbrpc_2fRPC_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_pbrpc_2fRPC_2eproto {
+ StaticDescriptorInitializer_pbrpc_2fRPC_2eproto() {
+ protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+ }
+} static_descriptor_initializer_pbrpc_2fRPC_2eproto_;
+
+const ::google::protobuf::EnumDescriptor* MessageType_descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return MessageType_descriptor_;
+}
+bool MessageType_IsValid(int value) {
+ switch(value) {
+ case 0:
+ case 1:
+ case 2:
+ return true;
+ default:
+ return false;
+ }
+}
+
+const ::google::protobuf::EnumDescriptor* AuthType_descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return AuthType_descriptor_;
+}
+bool AuthType_IsValid(int value) {
+ switch(value) {
+ case 0:
+ case 1:
+ return true;
+ default:
+ return false;
+ }
+}
+
+const ::google::protobuf::EnumDescriptor* ErrorType_descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return ErrorType_descriptor_;
+}
+bool ErrorType_IsValid(int value) {
+ switch(value) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ case 100:
+ return true;
+ default:
+ return false;
+ }
+}
+
+const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return POSIXErrno_descriptor_;
+}
+bool POSIXErrno_IsValid(int value) {
+ switch(value) {
+ case 1:
+ case 2:
+ case 5:
+ case 11:
+ case 13:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 21:
+ case 22:
+ case 39:
+ case 61:
+ case 9999:
+ return true;
+ default:
+ return false;
+ }
+}
+
+
+// ===================================================================
+
+const ::std::string UserCredentials::_default_username_;
+#ifndef _MSC_VER
+const int UserCredentials::kUsernameFieldNumber;
+const int UserCredentials::kGroupsFieldNumber;
+#endif // !_MSC_VER
+
+UserCredentials::UserCredentials()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void UserCredentials::InitAsDefaultInstance() {
+}
+
+UserCredentials::UserCredentials(const UserCredentials& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void UserCredentials::SharedCtor() {
+ _cached_size_ = 0;
+ username_ = const_cast< ::std::string*>(&_default_username_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UserCredentials::~UserCredentials() {
+ SharedDtor();
+}
+
+void UserCredentials::SharedDtor() {
+ if (username_ != &_default_username_) {
+ delete username_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void UserCredentials::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UserCredentials::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return UserCredentials_descriptor_;
+}
+
+const UserCredentials& UserCredentials::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+}
+
+UserCredentials* UserCredentials::default_instance_ = NULL;
+
+UserCredentials* UserCredentials::New() const {
+ return new UserCredentials;
+}
+
+void UserCredentials::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (username_ != &_default_username_) {
+ username_->clear();
+ }
+ }
+ }
+ groups_.Clear();
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool UserCredentials::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string username = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_username()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->username().data(), this->username().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(18)) goto parse_groups;
+ break;
+ }
+
+ // repeated string groups = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_groups:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->add_groups()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->groups(0).data(), this->groups(0).length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(18)) goto parse_groups;
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void UserCredentials::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string username = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->username().data(), this->username().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->username(), output);
+ }
+
+ // repeated string groups = 2;
+ for (int i = 0; i < this->groups_size(); i++) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->groups(i).data(), this->groups(i).length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 2, this->groups(i), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* UserCredentials::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string username = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->username().data(), this->username().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->username(), target);
+ }
+
+ // repeated string groups = 2;
+ for (int i = 0; i < this->groups_size(); i++) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->groups(i).data(), this->groups(i).length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteStringToArray(2, this->groups(i), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int UserCredentials::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string username = 1;
+ if (has_username()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->username());
+ }
+
+ }
+ // repeated string groups = 2;
+ total_size += 1 * this->groups_size();
+ for (int i = 0; i < this->groups_size(); i++) {
+ total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->groups(i));
+ }
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void UserCredentials::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const UserCredentials* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void UserCredentials::MergeFrom(const UserCredentials& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ groups_.MergeFrom(from.groups_);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_username(from.username());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UserCredentials::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void UserCredentials::CopyFrom(const UserCredentials& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool UserCredentials::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void UserCredentials::Swap(UserCredentials* other) {
+ if (other != this) {
+ std::swap(username_, other->username_);
+ groups_.Swap(&other->groups_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata UserCredentials::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = UserCredentials_descriptor_;
+ metadata.reflection = UserCredentials_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string AuthPassword::_default_password_;
+#ifndef _MSC_VER
+const int AuthPassword::kPasswordFieldNumber;
+#endif // !_MSC_VER
+
+AuthPassword::AuthPassword()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void AuthPassword::InitAsDefaultInstance() {
+}
+
+AuthPassword::AuthPassword(const AuthPassword& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void AuthPassword::SharedCtor() {
+ _cached_size_ = 0;
+ password_ = const_cast< ::std::string*>(&_default_password_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AuthPassword::~AuthPassword() {
+ SharedDtor();
+}
+
+void AuthPassword::SharedDtor() {
+ if (password_ != &_default_password_) {
+ delete password_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void AuthPassword::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AuthPassword::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return AuthPassword_descriptor_;
+}
+
+const AuthPassword& AuthPassword::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+}
+
+AuthPassword* AuthPassword::default_instance_ = NULL;
+
+AuthPassword* AuthPassword::New() const {
+ return new AuthPassword;
+}
+
+void AuthPassword::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (password_ != &_default_password_) {
+ password_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool AuthPassword::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string password = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_password()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->password().data(), this->password().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void AuthPassword::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string password = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->password().data(), this->password().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->password(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* AuthPassword::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string password = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->password().data(), this->password().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->password(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int AuthPassword::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string password = 1;
+ if (has_password()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->password());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void AuthPassword::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const AuthPassword* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void AuthPassword::MergeFrom(const AuthPassword& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_password(from.password());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AuthPassword::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void AuthPassword::CopyFrom(const AuthPassword& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool AuthPassword::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void AuthPassword::Swap(AuthPassword* other) {
+ if (other != this) {
+ std::swap(password_, other->password_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata AuthPassword::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = AuthPassword_descriptor_;
+ metadata.reflection = AuthPassword_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string Auth::_default_auth_data_;
+#ifndef _MSC_VER
+const int Auth::kAuthTypeFieldNumber;
+const int Auth::kAuthPasswdFieldNumber;
+const int Auth::kAuthDataFieldNumber;
+#endif // !_MSC_VER
+
+Auth::Auth()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void Auth::InitAsDefaultInstance() {
+ auth_passwd_ = const_cast< ::xtreemfs::pbrpc::AuthPassword*>(&::xtreemfs::pbrpc::AuthPassword::default_instance());
+}
+
+Auth::Auth(const Auth& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void Auth::SharedCtor() {
+ _cached_size_ = 0;
+ auth_type_ = 0;
+ auth_passwd_ = NULL;
+ auth_data_ = const_cast< ::std::string*>(&_default_auth_data_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Auth::~Auth() {
+ SharedDtor();
+}
+
+void Auth::SharedDtor() {
+ if (auth_data_ != &_default_auth_data_) {
+ delete auth_data_;
+ }
+ if (this != default_instance_) {
+ delete auth_passwd_;
+ }
+}
+
+void Auth::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Auth::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return Auth_descriptor_;
+}
+
+const Auth& Auth::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+}
+
+Auth* Auth::default_instance_ = NULL;
+
+Auth* Auth::New() const {
+ return new Auth;
+}
+
+void Auth::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ auth_type_ = 0;
+ if (_has_bit(1)) {
+ if (auth_passwd_ != NULL) auth_passwd_->::xtreemfs::pbrpc::AuthPassword::Clear();
+ }
+ if (_has_bit(2)) {
+ if (auth_data_ != &_default_auth_data_) {
+ auth_data_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool Auth::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required .xtreemfs.pbrpc.AuthType auth_type = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ int value;
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+ input, &value)));
+ if (xtreemfs::pbrpc::AuthType_IsValid(value)) {
+ set_auth_type(static_cast< xtreemfs::pbrpc::AuthType >(value));
+ } else {
+ mutable_unknown_fields()->AddVarint(1, value);
+ }
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(18)) goto parse_auth_data;
+ break;
+ }
+
+ // optional bytes auth_data = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_auth_data:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+ input, this->mutable_auth_data()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(26)) goto parse_auth_passwd;
+ break;
+ }
+
+ // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_auth_passwd:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_auth_passwd()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void Auth::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required .xtreemfs.pbrpc.AuthType auth_type = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteEnum(
+ 1, this->auth_type(), output);
+ }
+
+ // optional bytes auth_data = 2;
+ if (_has_bit(2)) {
+ ::google::protobuf::internal::WireFormatLite::WriteBytes(
+ 2, this->auth_data(), output);
+ }
+
+ // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
+ if (_has_bit(1)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 3, this->auth_passwd(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* Auth::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required .xtreemfs.pbrpc.AuthType auth_type = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+ 1, this->auth_type(), target);
+ }
+
+ // optional bytes auth_data = 2;
+ if (_has_bit(2)) {
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+ 2, this->auth_data(), target);
+ }
+
+ // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
+ if (_has_bit(1)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 3, this->auth_passwd(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int Auth::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required .xtreemfs.pbrpc.AuthType auth_type = 1;
+ if (has_auth_type()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::EnumSize(this->auth_type());
+ }
+
+ // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
+ if (has_auth_passwd()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->auth_passwd());
+ }
+
+ // optional bytes auth_data = 2;
+ if (has_auth_data()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::BytesSize(
+ this->auth_data());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void Auth::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const Auth* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void Auth::MergeFrom(const Auth& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_auth_type(from.auth_type());
+ }
+ if (from._has_bit(1)) {
+ mutable_auth_passwd()->::xtreemfs::pbrpc::AuthPassword::MergeFrom(from.auth_passwd());
+ }
+ if (from._has_bit(2)) {
+ set_auth_data(from.auth_data());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Auth::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Auth::CopyFrom(const Auth& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Auth::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ if (has_auth_passwd()) {
+ if (!this->auth_passwd().IsInitialized()) return false;
+ }
+ return true;
+}
+
+void Auth::Swap(Auth* other) {
+ if (other != this) {
+ std::swap(auth_type_, other->auth_type_);
+ std::swap(auth_passwd_, other->auth_passwd_);
+ std::swap(auth_data_, other->auth_data_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata Auth::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = Auth_descriptor_;
+ metadata.reflection = Auth_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RPCHeader_RequestHeader::kInterfaceIdFieldNumber;
+const int RPCHeader_RequestHeader::kProcIdFieldNumber;
+const int RPCHeader_RequestHeader::kUserCredsFieldNumber;
+const int RPCHeader_RequestHeader::kAuthDataFieldNumber;
+#endif // !_MSC_VER
+
+RPCHeader_RequestHeader::RPCHeader_RequestHeader()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void RPCHeader_RequestHeader::InitAsDefaultInstance() {
+ user_creds_ = const_cast< ::xtreemfs::pbrpc::UserCredentials*>(&::xtreemfs::pbrpc::UserCredentials::default_instance());
+ auth_data_ = const_cast< ::xtreemfs::pbrpc::Auth*>(&::xtreemfs::pbrpc::Auth::default_instance());
+}
+
+RPCHeader_RequestHeader::RPCHeader_RequestHeader(const RPCHeader_RequestHeader& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void RPCHeader_RequestHeader::SharedCtor() {
+ _cached_size_ = 0;
+ interface_id_ = 0u;
+ proc_id_ = 0u;
+ user_creds_ = NULL;
+ auth_data_ = NULL;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RPCHeader_RequestHeader::~RPCHeader_RequestHeader() {
+ SharedDtor();
+}
+
+void RPCHeader_RequestHeader::SharedDtor() {
+ if (this != default_instance_) {
+ delete user_creds_;
+ delete auth_data_;
+ }
+}
+
+void RPCHeader_RequestHeader::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RPCHeader_RequestHeader::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return RPCHeader_RequestHeader_descriptor_;
+}
+
+const RPCHeader_RequestHeader& RPCHeader_RequestHeader::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+}
+
+RPCHeader_RequestHeader* RPCHeader_RequestHeader::default_instance_ = NULL;
+
+RPCHeader_RequestHeader* RPCHeader_RequestHeader::New() const {
+ return new RPCHeader_RequestHeader;
+}
+
+void RPCHeader_RequestHeader::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ interface_id_ = 0u;
+ proc_id_ = 0u;
+ if (_has_bit(2)) {
+ if (user_creds_ != NULL) user_creds_->::xtreemfs::pbrpc::UserCredentials::Clear();
+ }
+ if (_has_bit(3)) {
+ if (auth_data_ != NULL) auth_data_->::xtreemfs::pbrpc::Auth::Clear();
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool RPCHeader_RequestHeader::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required fixed32 interface_id = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+ input, &interface_id_)));
+ _set_bit(0);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(21)) goto parse_proc_id;
+ break;
+ }
+
+ // required fixed32 proc_id = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+ parse_proc_id:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+ input, &proc_id_)));
+ _set_bit(1);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(26)) goto parse_user_creds;
+ break;
+ }
+
+ // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_user_creds:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_user_creds()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(34)) goto parse_auth_data;
+ break;
+ }
+
+ // required .xtreemfs.pbrpc.Auth auth_data = 4;
+ case 4: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_auth_data:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_auth_data()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void RPCHeader_RequestHeader::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required fixed32 interface_id = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->interface_id(), output);
+ }
+
+ // required fixed32 proc_id = 2;
+ if (_has_bit(1)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->proc_id(), output);
+ }
+
+ // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
+ if (_has_bit(2)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 3, this->user_creds(), output);
+ }
+
+ // required .xtreemfs.pbrpc.Auth auth_data = 4;
+ if (_has_bit(3)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 4, this->auth_data(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* RPCHeader_RequestHeader::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required fixed32 interface_id = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->interface_id(), target);
+ }
+
+ // required fixed32 proc_id = 2;
+ if (_has_bit(1)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->proc_id(), target);
+ }
+
+ // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
+ if (_has_bit(2)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 3, this->user_creds(), target);
+ }
+
+ // required .xtreemfs.pbrpc.Auth auth_data = 4;
+ if (_has_bit(3)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 4, this->auth_data(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int RPCHeader_RequestHeader::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required fixed32 interface_id = 1;
+ if (has_interface_id()) {
+ total_size += 1 + 4;
+ }
+
+ // required fixed32 proc_id = 2;
+ if (has_proc_id()) {
+ total_size += 1 + 4;
+ }
+
+ // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
+ if (has_user_creds()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->user_creds());
+ }
+
+ // required .xtreemfs.pbrpc.Auth auth_data = 4;
+ if (has_auth_data()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->auth_data());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void RPCHeader_RequestHeader::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const RPCHeader_RequestHeader* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void RPCHeader_RequestHeader::MergeFrom(const RPCHeader_RequestHeader& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_interface_id(from.interface_id());
+ }
+ if (from._has_bit(1)) {
+ set_proc_id(from.proc_id());
+ }
+ if (from._has_bit(2)) {
+ mutable_user_creds()->::xtreemfs::pbrpc::UserCredentials::MergeFrom(from.user_creds());
+ }
+ if (from._has_bit(3)) {
+ mutable_auth_data()->::xtreemfs::pbrpc::Auth::MergeFrom(from.auth_data());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RPCHeader_RequestHeader::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void RPCHeader_RequestHeader::CopyFrom(const RPCHeader_RequestHeader& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool RPCHeader_RequestHeader::IsInitialized() const {
+ if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
+
+ if (has_user_creds()) {
+ if (!this->user_creds().IsInitialized()) return false;
+ }
+ if (has_auth_data()) {
+ if (!this->auth_data().IsInitialized()) return false;
+ }
+ return true;
+}
+
+void RPCHeader_RequestHeader::Swap(RPCHeader_RequestHeader* other) {
+ if (other != this) {
+ std::swap(interface_id_, other->interface_id_);
+ std::swap(proc_id_, other->proc_id_);
+ std::swap(user_creds_, other->user_creds_);
+ std::swap(auth_data_, other->auth_data_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata RPCHeader_RequestHeader::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = RPCHeader_RequestHeader_descriptor_;
+ metadata.reflection = RPCHeader_RequestHeader_reflection_;
+ return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+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;
+const int RPCHeader_ErrorResponse::kErrorMessageFieldNumber;
+const int RPCHeader_ErrorResponse::kDebugInfoFieldNumber;
+const int RPCHeader_ErrorResponse::kRedirectToServerUuidFieldNumber;
+#endif // !_MSC_VER
+
+RPCHeader_ErrorResponse::RPCHeader_ErrorResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void RPCHeader_ErrorResponse::InitAsDefaultInstance() {
+}
+
+RPCHeader_ErrorResponse::RPCHeader_ErrorResponse(const RPCHeader_ErrorResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void RPCHeader_ErrorResponse::SharedCtor() {
+ _cached_size_ = 0;
+ error_type_ = 1;
+ posix_errno_ = 9999;
+ error_message_ = const_cast< ::std::string*>(&_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_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RPCHeader_ErrorResponse::~RPCHeader_ErrorResponse() {
+ SharedDtor();
+}
+
+void RPCHeader_ErrorResponse::SharedDtor() {
+ if (error_message_ != &_default_error_message_) {
+ delete error_message_;
+ }
+ if (debug_info_ != &_default_debug_info_) {
+ delete debug_info_;
+ }
+ if (redirect_to_server_uuid_ != &_default_redirect_to_server_uuid_) {
+ delete redirect_to_server_uuid_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void RPCHeader_ErrorResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RPCHeader_ErrorResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return RPCHeader_ErrorResponse_descriptor_;
+}
+
+const RPCHeader_ErrorResponse& RPCHeader_ErrorResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+}
+
+RPCHeader_ErrorResponse* RPCHeader_ErrorResponse::default_instance_ = NULL;
+
+RPCHeader_ErrorResponse* RPCHeader_ErrorResponse::New() const {
+ return new RPCHeader_ErrorResponse;
+}
+
+void RPCHeader_ErrorResponse::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ error_type_ = 1;
+ posix_errno_ = 9999;
+ if (_has_bit(2)) {
+ if (error_message_ != &_default_error_message_) {
+ error_message_->clear();
+ }
+ }
+ if (_has_bit(3)) {
+ if (debug_info_ != &_default_debug_info_) {
+ debug_info_->clear();
+ }
+ }
+ if (_has_bit(4)) {
+ if (redirect_to_server_uuid_ != &_default_redirect_to_server_uuid_) {
+ redirect_to_server_uuid_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required .xtreemfs.pbrpc.ErrorType error_type = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ int value;
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+ input, &value)));
+ if (xtreemfs::pbrpc::ErrorType_IsValid(value)) {
+ set_error_type(static_cast< xtreemfs::pbrpc::ErrorType >(value));
+ } else {
+ mutable_unknown_fields()->AddVarint(1, value);
+ }
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(16)) goto parse_posix_errno;
+ break;
+ }
+
+ // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ parse_posix_errno:
+ int value;
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+ input, &value)));
+ if (xtreemfs::pbrpc::POSIXErrno_IsValid(value)) {
+ set_posix_errno(static_cast< xtreemfs::pbrpc::POSIXErrno >(value));
+ } else {
+ mutable_unknown_fields()->AddVarint(2, value);
+ }
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(26)) goto parse_error_message;
+ break;
+ }
+
+ // optional string error_message = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_error_message:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_error_message()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->error_message().data(), this->error_message().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(34)) goto parse_debug_info;
+ break;
+ }
+
+ // optional string debug_info = 4;
+ case 4: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_debug_info:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_debug_info()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->debug_info().data(), this->debug_info().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(42)) goto parse_redirect_to_server_uuid;
+ break;
+ }
+
+ // optional string redirect_to_server_uuid = 5;
+ case 5: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_redirect_to_server_uuid:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_redirect_to_server_uuid()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required .xtreemfs.pbrpc.ErrorType error_type = 1;
+ if (_has_bit(0)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteEnum(
+ 2, this->posix_errno(), output);
+ }
+
+ // optional string error_message = 3;
+ if (_has_bit(2)) {
+ ::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)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 5, this->redirect_to_server_uuid(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* RPCHeader_ErrorResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required .xtreemfs.pbrpc.ErrorType error_type = 1;
+ if (_has_bit(0)) {
+ 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)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+ 2, this->posix_errno(), target);
+ }
+
+ // optional string error_message = 3;
+ if (_has_bit(2)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->error_message().data(), this->error_message().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 3, this->error_message(), target);
+ }
+
+ // optional string debug_info = 4;
+ if (_has_bit(3)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->debug_info().data(), this->debug_info().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 4, this->debug_info(), target);
+ }
+
+ // optional string redirect_to_server_uuid = 5;
+ if (_has_bit(4)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 5, this->redirect_to_server_uuid(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int RPCHeader_ErrorResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required .xtreemfs.pbrpc.ErrorType error_type = 1;
+ if (has_error_type()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::EnumSize(this->error_type());
+ }
+
+ // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
+ if (has_posix_errno()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::EnumSize(this->posix_errno());
+ }
+
+ // optional string error_message = 3;
+ if (has_error_message()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->error_message());
+ }
+
+ // optional string debug_info = 4;
+ if (has_debug_info()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->debug_info());
+ }
+
+ // optional string redirect_to_server_uuid = 5;
+ if (has_redirect_to_server_uuid()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->redirect_to_server_uuid());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void RPCHeader_ErrorResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const RPCHeader_ErrorResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void RPCHeader_ErrorResponse::MergeFrom(const RPCHeader_ErrorResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_error_type(from.error_type());
+ }
+ if (from._has_bit(1)) {
+ set_posix_errno(from.posix_errno());
+ }
+ if (from._has_bit(2)) {
+ set_error_message(from.error_message());
+ }
+ if (from._has_bit(3)) {
+ set_debug_info(from.debug_info());
+ }
+ if (from._has_bit(4)) {
+ set_redirect_to_server_uuid(from.redirect_to_server_uuid());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RPCHeader_ErrorResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void RPCHeader_ErrorResponse::CopyFrom(const RPCHeader_ErrorResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool RPCHeader_ErrorResponse::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void RPCHeader_ErrorResponse::Swap(RPCHeader_ErrorResponse* other) {
+ if (other != this) {
+ std::swap(error_type_, other->error_type_);
+ std::swap(posix_errno_, other->posix_errno_);
+ std::swap(error_message_, other->error_message_);
+ std::swap(debug_info_, other->debug_info_);
+ std::swap(redirect_to_server_uuid_, other->redirect_to_server_uuid_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata RPCHeader_ErrorResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = RPCHeader_ErrorResponse_descriptor_;
+ metadata.reflection = RPCHeader_ErrorResponse_reflection_;
+ return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int RPCHeader::kCallIdFieldNumber;
+const int RPCHeader::kMessageTypeFieldNumber;
+const int RPCHeader::kRequestHeaderFieldNumber;
+const int RPCHeader::kErrorResponseFieldNumber;
+#endif // !_MSC_VER
+
+RPCHeader::RPCHeader()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void RPCHeader::InitAsDefaultInstance() {
+ request_header_ = const_cast< ::xtreemfs::pbrpc::RPCHeader_RequestHeader*>(&::xtreemfs::pbrpc::RPCHeader_RequestHeader::default_instance());
+ error_response_ = const_cast< ::xtreemfs::pbrpc::RPCHeader_ErrorResponse*>(&::xtreemfs::pbrpc::RPCHeader_ErrorResponse::default_instance());
+}
+
+RPCHeader::RPCHeader(const RPCHeader& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void RPCHeader::SharedCtor() {
+ _cached_size_ = 0;
+ call_id_ = 0u;
+ message_type_ = 0;
+ request_header_ = NULL;
+ error_response_ = NULL;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RPCHeader::~RPCHeader() {
+ SharedDtor();
+}
+
+void RPCHeader::SharedDtor() {
+ if (this != default_instance_) {
+ delete request_header_;
+ delete error_response_;
+ }
+}
+
+void RPCHeader::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RPCHeader::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return RPCHeader_descriptor_;
+}
+
+const RPCHeader& RPCHeader::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto(); return *default_instance_;
+}
+
+RPCHeader* RPCHeader::default_instance_ = NULL;
+
+RPCHeader* RPCHeader::New() const {
+ return new RPCHeader;
+}
+
+void RPCHeader::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ call_id_ = 0u;
+ message_type_ = 0;
+ if (_has_bit(2)) {
+ if (request_header_ != NULL) request_header_->::xtreemfs::pbrpc::RPCHeader_RequestHeader::Clear();
+ }
+ if (_has_bit(3)) {
+ if (error_response_ != NULL) error_response_->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::Clear();
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool RPCHeader::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required fixed32 call_id = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+ input, &call_id_)));
+ _set_bit(0);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(16)) goto parse_message_type;
+ break;
+ }
+
+ // required .xtreemfs.pbrpc.MessageType message_type = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ parse_message_type:
+ int value;
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+ input, &value)));
+ if (xtreemfs::pbrpc::MessageType_IsValid(value)) {
+ set_message_type(static_cast< xtreemfs::pbrpc::MessageType >(value));
+ } else {
+ mutable_unknown_fields()->AddVarint(2, value);
+ }
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(26)) goto parse_request_header;
+ break;
+ }
+
+ // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_request_header:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_request_header()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(34)) goto parse_error_response;
+ break;
+ }
+
+ // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
+ case 4: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_error_response:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_error_response()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void RPCHeader::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required fixed32 call_id = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->call_id(), output);
+ }
+
+ // required .xtreemfs.pbrpc.MessageType message_type = 2;
+ if (_has_bit(1)) {
+ ::google::protobuf::internal::WireFormatLite::WriteEnum(
+ 2, this->message_type(), output);
+ }
+
+ // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
+ if (_has_bit(2)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 3, this->request_header(), output);
+ }
+
+ // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
+ if (_has_bit(3)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 4, this->error_response(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* RPCHeader::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required fixed32 call_id = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->call_id(), target);
+ }
+
+ // required .xtreemfs.pbrpc.MessageType message_type = 2;
+ if (_has_bit(1)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+ 2, this->message_type(), target);
+ }
+
+ // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
+ if (_has_bit(2)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 3, this->request_header(), target);
+ }
+
+ // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
+ if (_has_bit(3)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 4, this->error_response(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int RPCHeader::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required fixed32 call_id = 1;
+ if (has_call_id()) {
+ total_size += 1 + 4;
+ }
+
+ // required .xtreemfs.pbrpc.MessageType message_type = 2;
+ if (has_message_type()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::EnumSize(this->message_type());
+ }
+
+ // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
+ if (has_request_header()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->request_header());
+ }
+
+ // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
+ if (has_error_response()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->error_response());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void RPCHeader::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const RPCHeader* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void RPCHeader::MergeFrom(const RPCHeader& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_call_id(from.call_id());
+ }
+ if (from._has_bit(1)) {
+ set_message_type(from.message_type());
+ }
+ if (from._has_bit(2)) {
+ mutable_request_header()->::xtreemfs::pbrpc::RPCHeader_RequestHeader::MergeFrom(from.request_header());
+ }
+ if (from._has_bit(3)) {
+ mutable_error_response()->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::MergeFrom(from.error_response());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RPCHeader::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void RPCHeader::CopyFrom(const RPCHeader& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool RPCHeader::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+ if (has_request_header()) {
+ if (!this->request_header().IsInitialized()) return false;
+ }
+ if (has_error_response()) {
+ if (!this->error_response().IsInitialized()) return false;
+ }
+ return true;
+}
+
+void RPCHeader::Swap(RPCHeader* other) {
+ if (other != this) {
+ std::swap(call_id_, other->call_id_);
+ std::swap(message_type_, other->message_type_);
+ std::swap(request_header_, other->request_header_);
+ std::swap(error_response_, other->error_response_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata RPCHeader::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = RPCHeader_descriptor_;
+ metadata.reflection = RPCHeader_reflection_;
+ return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/cpp/generated/pbrpc/RPC.pb.h b/cpp/generated/pbrpc/RPC.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cce894845bf97b23b00cc1d1b82216d1593b842
--- /dev/null
+++ b/cpp/generated/pbrpc/RPC.pb.h
@@ -0,0 +1,1369 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: pbrpc/RPC.proto
+
+#ifndef PROTOBUF_pbrpc_2fRPC_2eproto__INCLUDED
+#define PROTOBUF_pbrpc_2fRPC_2eproto__INCLUDED
+
+#include
+
+#include
+
+#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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
+#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
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+// Internal implementation detail -- do not call these.
+void protobuf_AddDesc_pbrpc_2fRPC_2eproto();
+void protobuf_AssignDesc_pbrpc_2fRPC_2eproto();
+void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto();
+
+class UserCredentials;
+class AuthPassword;
+class Auth;
+class RPCHeader;
+class RPCHeader_RequestHeader;
+class RPCHeader_ErrorResponse;
+
+enum MessageType {
+ RPC_REQUEST = 0,
+ RPC_RESPONSE_SUCCESS = 1,
+ RPC_RESPONSE_ERROR = 2
+};
+bool MessageType_IsValid(int value);
+const MessageType MessageType_MIN = RPC_REQUEST;
+const MessageType MessageType_MAX = RPC_RESPONSE_ERROR;
+const int MessageType_ARRAYSIZE = MessageType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* MessageType_descriptor();
+inline const ::std::string& MessageType_Name(MessageType value) {
+ return ::google::protobuf::internal::NameOfEnum(
+ MessageType_descriptor(), value);
+}
+inline bool MessageType_Parse(
+ const ::std::string& name, MessageType* value) {
+ return ::google::protobuf::internal::ParseNamedEnum(
+ MessageType_descriptor(), name, value);
+}
+enum AuthType {
+ AUTH_NONE = 0,
+ AUTH_PASSWORD = 1
+};
+bool AuthType_IsValid(int value);
+const AuthType AuthType_MIN = AUTH_NONE;
+const AuthType AuthType_MAX = AUTH_PASSWORD;
+const int AuthType_ARRAYSIZE = AuthType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* AuthType_descriptor();
+inline const ::std::string& AuthType_Name(AuthType value) {
+ return ::google::protobuf::internal::NameOfEnum(
+ AuthType_descriptor(), value);
+}
+inline bool AuthType_Parse(
+ const ::std::string& name, AuthType* value) {
+ return ::google::protobuf::internal::ParseNamedEnum(
+ AuthType_descriptor(), name, value);
+}
+enum ErrorType {
+ INVALID_INTERFACE_ID = 1,
+ INVALID_PROC_ID = 2,
+ GARBAGE_ARGS = 3,
+ AUTH_FAILED = 4,
+ INTERNAL_SERVER_ERROR = 5,
+ ERRNO = 6,
+ REDIRECT = 7,
+ IO_ERROR = 100
+};
+bool ErrorType_IsValid(int value);
+const ErrorType ErrorType_MIN = INVALID_INTERFACE_ID;
+const ErrorType ErrorType_MAX = IO_ERROR;
+const int ErrorType_ARRAYSIZE = ErrorType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ErrorType_descriptor();
+inline const ::std::string& ErrorType_Name(ErrorType value) {
+ return ::google::protobuf::internal::NameOfEnum(
+ ErrorType_descriptor(), value);
+}
+inline bool ErrorType_Parse(
+ const ::std::string& name, ErrorType* value) {
+ return ::google::protobuf::internal::ParseNamedEnum(
+ ErrorType_descriptor(), name, value);
+}
+enum POSIXErrno {
+ POSIX_ERROR_NONE = 9999,
+ POSIX_ERROR_EPERM = 1,
+ POSIX_ERROR_ENOENT = 2,
+ POSIX_ERROR_EIO = 5,
+ POSIX_ERROR_EAGAIN = 11,
+ POSIX_ERROR_EACCES = 13,
+ POSIX_ERROR_EEXIST = 17,
+ POSIX_ERROR_EXDEV = 18,
+ POSIX_ERROR_ENODEV = 19,
+ POSIX_ERROR_ENOTDIR = 20,
+ POSIX_ERROR_EISDIR = 21,
+ POSIX_ERROR_EINVAL = 22,
+ POSIX_ERROR_ENOTEMPTY = 39,
+ POSIX_ERROR_ENODATA = 61
+};
+bool POSIXErrno_IsValid(int value);
+const POSIXErrno POSIXErrno_MIN = POSIX_ERROR_EPERM;
+const POSIXErrno POSIXErrno_MAX = POSIX_ERROR_NONE;
+const int POSIXErrno_ARRAYSIZE = POSIXErrno_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor();
+inline const ::std::string& POSIXErrno_Name(POSIXErrno value) {
+ return ::google::protobuf::internal::NameOfEnum(
+ POSIXErrno_descriptor(), value);
+}
+inline bool POSIXErrno_Parse(
+ const ::std::string& name, POSIXErrno* value) {
+ return ::google::protobuf::internal::ParseNamedEnum(
+ POSIXErrno_descriptor(), name, value);
+}
+// ===================================================================
+
+class UserCredentials : public ::google::protobuf::Message {
+ public:
+ UserCredentials();
+ virtual ~UserCredentials();
+
+ UserCredentials(const UserCredentials& from);
+
+ inline UserCredentials& operator=(const UserCredentials& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const UserCredentials& default_instance();
+
+ void Swap(UserCredentials* other);
+
+ // implements Message ----------------------------------------------
+
+ UserCredentials* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const UserCredentials& from);
+ void MergeFrom(const UserCredentials& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string username = 1;
+ inline bool has_username() const;
+ inline void clear_username();
+ static const int kUsernameFieldNumber = 1;
+ inline const ::std::string& username() const;
+ inline void set_username(const ::std::string& value);
+ inline void set_username(const char* value);
+ inline void set_username(const char* value, size_t size);
+ inline ::std::string* mutable_username();
+
+ // repeated string groups = 2;
+ inline int groups_size() const;
+ inline void clear_groups();
+ static const int kGroupsFieldNumber = 2;
+ inline const ::std::string& groups(int index) const;
+ inline ::std::string* mutable_groups(int index);
+ inline void set_groups(int index, const ::std::string& value);
+ inline void set_groups(int index, const char* value);
+ inline void set_groups(int index, const char* value, size_t size);
+ inline ::std::string* add_groups();
+ inline void add_groups(const ::std::string& value);
+ inline void add_groups(const char* value);
+ inline void add_groups(const char* value, size_t size);
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>& groups() const;
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_groups();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.UserCredentials)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* username_;
+ static const ::std::string _default_username_;
+ ::google::protobuf::RepeatedPtrField< ::std::string> groups_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class AuthPassword : public ::google::protobuf::Message {
+ public:
+ AuthPassword();
+ virtual ~AuthPassword();
+
+ AuthPassword(const AuthPassword& from);
+
+ inline AuthPassword& operator=(const AuthPassword& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const AuthPassword& default_instance();
+
+ void Swap(AuthPassword* other);
+
+ // implements Message ----------------------------------------------
+
+ AuthPassword* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const AuthPassword& from);
+ void MergeFrom(const AuthPassword& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string password = 1;
+ inline bool has_password() const;
+ inline void clear_password();
+ static const int kPasswordFieldNumber = 1;
+ inline const ::std::string& password() const;
+ inline void set_password(const ::std::string& value);
+ inline void set_password(const char* value);
+ inline void set_password(const char* value, size_t size);
+ inline ::std::string* mutable_password();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.AuthPassword)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* password_;
+ static const ::std::string _default_password_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class Auth : public ::google::protobuf::Message {
+ public:
+ Auth();
+ virtual ~Auth();
+
+ Auth(const Auth& from);
+
+ inline Auth& operator=(const Auth& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const Auth& default_instance();
+
+ void Swap(Auth* other);
+
+ // implements Message ----------------------------------------------
+
+ Auth* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const Auth& from);
+ void MergeFrom(const Auth& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required .xtreemfs.pbrpc.AuthType auth_type = 1;
+ inline bool has_auth_type() const;
+ inline void clear_auth_type();
+ static const int kAuthTypeFieldNumber = 1;
+ inline xtreemfs::pbrpc::AuthType auth_type() const;
+ inline void set_auth_type(xtreemfs::pbrpc::AuthType value);
+
+ // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
+ inline bool has_auth_passwd() const;
+ inline void clear_auth_passwd();
+ static const int kAuthPasswdFieldNumber = 3;
+ inline const ::xtreemfs::pbrpc::AuthPassword& auth_passwd() const;
+ inline ::xtreemfs::pbrpc::AuthPassword* mutable_auth_passwd();
+
+ // optional bytes auth_data = 2;
+ inline bool has_auth_data() const;
+ inline void clear_auth_data();
+ static const int kAuthDataFieldNumber = 2;
+ inline const ::std::string& auth_data() const;
+ inline void set_auth_data(const ::std::string& value);
+ inline void set_auth_data(const char* value);
+ inline void set_auth_data(const void* value, size_t size);
+ inline ::std::string* mutable_auth_data();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Auth)
+ private:
+ ::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_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class RPCHeader_RequestHeader : public ::google::protobuf::Message {
+ public:
+ RPCHeader_RequestHeader();
+ virtual ~RPCHeader_RequestHeader();
+
+ RPCHeader_RequestHeader(const RPCHeader_RequestHeader& from);
+
+ inline RPCHeader_RequestHeader& operator=(const RPCHeader_RequestHeader& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const RPCHeader_RequestHeader& default_instance();
+
+ void Swap(RPCHeader_RequestHeader* other);
+
+ // implements Message ----------------------------------------------
+
+ RPCHeader_RequestHeader* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const RPCHeader_RequestHeader& from);
+ void MergeFrom(const RPCHeader_RequestHeader& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required fixed32 interface_id = 1;
+ inline bool has_interface_id() const;
+ inline void clear_interface_id();
+ static const int kInterfaceIdFieldNumber = 1;
+ inline ::google::protobuf::uint32 interface_id() const;
+ inline void set_interface_id(::google::protobuf::uint32 value);
+
+ // required fixed32 proc_id = 2;
+ inline bool has_proc_id() const;
+ inline void clear_proc_id();
+ static const int kProcIdFieldNumber = 2;
+ inline ::google::protobuf::uint32 proc_id() const;
+ inline void set_proc_id(::google::protobuf::uint32 value);
+
+ // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
+ inline bool has_user_creds() const;
+ inline void clear_user_creds();
+ static const int kUserCredsFieldNumber = 3;
+ inline const ::xtreemfs::pbrpc::UserCredentials& user_creds() const;
+ inline ::xtreemfs::pbrpc::UserCredentials* mutable_user_creds();
+
+ // 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();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.RPCHeader.RequestHeader)
+ private:
+ ::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_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class RPCHeader_ErrorResponse : public ::google::protobuf::Message {
+ public:
+ RPCHeader_ErrorResponse();
+ virtual ~RPCHeader_ErrorResponse();
+
+ RPCHeader_ErrorResponse(const RPCHeader_ErrorResponse& from);
+
+ inline RPCHeader_ErrorResponse& operator=(const RPCHeader_ErrorResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const RPCHeader_ErrorResponse& default_instance();
+
+ void Swap(RPCHeader_ErrorResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ RPCHeader_ErrorResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const RPCHeader_ErrorResponse& from);
+ void MergeFrom(const RPCHeader_ErrorResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required .xtreemfs.pbrpc.ErrorType error_type = 1;
+ inline bool has_error_type() const;
+ inline void clear_error_type();
+ static const int kErrorTypeFieldNumber = 1;
+ inline xtreemfs::pbrpc::ErrorType error_type() const;
+ inline void set_error_type(xtreemfs::pbrpc::ErrorType value);
+
+ // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
+ inline bool has_posix_errno() const;
+ inline void clear_posix_errno();
+ static const int kPosixErrnoFieldNumber = 2;
+ inline xtreemfs::pbrpc::POSIXErrno posix_errno() const;
+ inline void set_posix_errno(xtreemfs::pbrpc::POSIXErrno value);
+
+ // optional string error_message = 3;
+ inline bool has_error_message() const;
+ inline void clear_error_message();
+ static const int kErrorMessageFieldNumber = 3;
+ inline const ::std::string& error_message() const;
+ inline void set_error_message(const ::std::string& value);
+ inline void set_error_message(const char* value);
+ inline void set_error_message(const char* value, size_t size);
+ inline ::std::string* mutable_error_message();
+
+ // optional string debug_info = 4;
+ inline bool has_debug_info() const;
+ inline void clear_debug_info();
+ static const int kDebugInfoFieldNumber = 4;
+ inline const ::std::string& debug_info() const;
+ inline void set_debug_info(const ::std::string& value);
+ inline void set_debug_info(const char* value);
+ inline void set_debug_info(const char* value, size_t size);
+ inline ::std::string* mutable_debug_info();
+
+ // optional string redirect_to_server_uuid = 5;
+ inline bool has_redirect_to_server_uuid() const;
+ inline void clear_redirect_to_server_uuid();
+ static const int kRedirectToServerUuidFieldNumber = 5;
+ inline const ::std::string& redirect_to_server_uuid() const;
+ inline void set_redirect_to_server_uuid(const ::std::string& value);
+ inline void set_redirect_to_server_uuid(const char* value);
+ inline void set_redirect_to_server_uuid(const char* value, size_t size);
+ inline ::std::string* mutable_redirect_to_server_uuid();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.RPCHeader.ErrorResponse)
+ private:
+ ::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_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class RPCHeader : public ::google::protobuf::Message {
+ public:
+ RPCHeader();
+ virtual ~RPCHeader();
+
+ RPCHeader(const RPCHeader& from);
+
+ inline RPCHeader& operator=(const RPCHeader& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const RPCHeader& default_instance();
+
+ void Swap(RPCHeader* other);
+
+ // implements Message ----------------------------------------------
+
+ RPCHeader* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const RPCHeader& from);
+ void MergeFrom(const RPCHeader& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ typedef RPCHeader_RequestHeader RequestHeader;
+ typedef RPCHeader_ErrorResponse ErrorResponse;
+
+ // accessors -------------------------------------------------------
+
+ // required fixed32 call_id = 1;
+ inline bool has_call_id() const;
+ inline void clear_call_id();
+ static const int kCallIdFieldNumber = 1;
+ inline ::google::protobuf::uint32 call_id() const;
+ inline void set_call_id(::google::protobuf::uint32 value);
+
+ // required .xtreemfs.pbrpc.MessageType message_type = 2;
+ inline bool has_message_type() const;
+ inline void clear_message_type();
+ static const int kMessageTypeFieldNumber = 2;
+ inline xtreemfs::pbrpc::MessageType message_type() const;
+ inline void set_message_type(xtreemfs::pbrpc::MessageType value);
+
+ // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
+ inline bool has_request_header() const;
+ inline void clear_request_header();
+ static const int kRequestHeaderFieldNumber = 3;
+ inline const ::xtreemfs::pbrpc::RPCHeader_RequestHeader& request_header() const;
+ inline ::xtreemfs::pbrpc::RPCHeader_RequestHeader* mutable_request_header();
+
+ // 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();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.RPCHeader)
+ private:
+ ::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_;
+ 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_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// UserCredentials
+
+// required string username = 1;
+inline bool UserCredentials::has_username() const {
+ return _has_bit(0);
+}
+inline void UserCredentials::clear_username() {
+ if (username_ != &_default_username_) {
+ username_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ username_ = new ::std::string;
+ }
+ username_->assign(value);
+}
+inline void UserCredentials::set_username(const char* value) {
+ _set_bit(0);
+ if (username_ == &_default_username_) {
+ 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_) {
+ username_ = new ::std::string;
+ }
+ username_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* UserCredentials::mutable_username() {
+ _set_bit(0);
+ if (username_ == &_default_username_) {
+ username_ = new ::std::string;
+ }
+ return username_;
+}
+
+// repeated string groups = 2;
+inline int UserCredentials::groups_size() const {
+ return groups_.size();
+}
+inline void UserCredentials::clear_groups() {
+ groups_.Clear();
+}
+inline const ::std::string& UserCredentials::groups(int index) const {
+ return groups_.Get(index);
+}
+inline ::std::string* UserCredentials::mutable_groups(int index) {
+ return groups_.Mutable(index);
+}
+inline void UserCredentials::set_groups(int index, const ::std::string& value) {
+ groups_.Mutable(index)->assign(value);
+}
+inline void UserCredentials::set_groups(int index, const char* value) {
+ groups_.Mutable(index)->assign(value);
+}
+inline void UserCredentials::set_groups(int index, const char* value, size_t size) {
+ groups_.Mutable(index)->assign(
+ reinterpret_cast(value), size);
+}
+inline ::std::string* UserCredentials::add_groups() {
+ return groups_.Add();
+}
+inline void UserCredentials::add_groups(const ::std::string& value) {
+ groups_.Add()->assign(value);
+}
+inline void UserCredentials::add_groups(const char* value) {
+ groups_.Add()->assign(value);
+}
+inline void UserCredentials::add_groups(const char* value, size_t size) {
+ groups_.Add()->assign(reinterpret_cast(value), size);
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+UserCredentials::groups() const {
+ return groups_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+UserCredentials::mutable_groups() {
+ return &groups_;
+}
+
+// -------------------------------------------------------------------
+
+// AuthPassword
+
+// required string password = 1;
+inline bool AuthPassword::has_password() const {
+ return _has_bit(0);
+}
+inline void AuthPassword::clear_password() {
+ if (password_ != &_default_password_) {
+ password_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ password_ = new ::std::string;
+ }
+ password_->assign(value);
+}
+inline void AuthPassword::set_password(const char* value) {
+ _set_bit(0);
+ if (password_ == &_default_password_) {
+ 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_) {
+ password_ = new ::std::string;
+ }
+ password_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* AuthPassword::mutable_password() {
+ _set_bit(0);
+ if (password_ == &_default_password_) {
+ password_ = new ::std::string;
+ }
+ return password_;
+}
+
+// -------------------------------------------------------------------
+
+// Auth
+
+// required .xtreemfs.pbrpc.AuthType auth_type = 1;
+inline bool Auth::has_auth_type() const {
+ return _has_bit(0);
+}
+inline void Auth::clear_auth_type() {
+ auth_type_ = 0;
+ _clear_bit(0);
+}
+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);
+ auth_type_ = value;
+}
+
+// optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
+inline bool Auth::has_auth_passwd() const {
+ return _has_bit(1);
+}
+inline void Auth::clear_auth_passwd() {
+ if (auth_passwd_ != NULL) auth_passwd_->::xtreemfs::pbrpc::AuthPassword::Clear();
+ _clear_bit(1);
+}
+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);
+ if (auth_passwd_ == NULL) auth_passwd_ = new ::xtreemfs::pbrpc::AuthPassword;
+ return auth_passwd_;
+}
+
+// optional bytes auth_data = 2;
+inline bool Auth::has_auth_data() const {
+ return _has_bit(2);
+}
+inline void Auth::clear_auth_data() {
+ if (auth_data_ != &_default_auth_data_) {
+ auth_data_->clear();
+ }
+ _clear_bit(2);
+}
+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_) {
+ 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_) {
+ 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_) {
+ 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_) {
+ auth_data_ = new ::std::string;
+ }
+ return auth_data_;
+}
+
+// -------------------------------------------------------------------
+
+// RPCHeader_RequestHeader
+
+// required fixed32 interface_id = 1;
+inline bool RPCHeader_RequestHeader::has_interface_id() const {
+ return _has_bit(0);
+}
+inline void RPCHeader_RequestHeader::clear_interface_id() {
+ interface_id_ = 0u;
+ _clear_bit(0);
+}
+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);
+ interface_id_ = value;
+}
+
+// required fixed32 proc_id = 2;
+inline bool RPCHeader_RequestHeader::has_proc_id() const {
+ return _has_bit(1);
+}
+inline void RPCHeader_RequestHeader::clear_proc_id() {
+ proc_id_ = 0u;
+ _clear_bit(1);
+}
+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);
+ proc_id_ = value;
+}
+
+// required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
+inline bool RPCHeader_RequestHeader::has_user_creds() const {
+ return _has_bit(2);
+}
+inline void RPCHeader_RequestHeader::clear_user_creds() {
+ if (user_creds_ != NULL) user_creds_->::xtreemfs::pbrpc::UserCredentials::Clear();
+ _clear_bit(2);
+}
+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);
+ if (user_creds_ == NULL) user_creds_ = new ::xtreemfs::pbrpc::UserCredentials;
+ return user_creds_;
+}
+
+// required .xtreemfs.pbrpc.Auth auth_data = 4;
+inline bool RPCHeader_RequestHeader::has_auth_data() const {
+ return _has_bit(3);
+}
+inline void RPCHeader_RequestHeader::clear_auth_data() {
+ if (auth_data_ != NULL) auth_data_->::xtreemfs::pbrpc::Auth::Clear();
+ _clear_bit(3);
+}
+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);
+ if (auth_data_ == NULL) auth_data_ = new ::xtreemfs::pbrpc::Auth;
+ return auth_data_;
+}
+
+// -------------------------------------------------------------------
+
+// RPCHeader_ErrorResponse
+
+// required .xtreemfs.pbrpc.ErrorType error_type = 1;
+inline bool RPCHeader_ErrorResponse::has_error_type() const {
+ return _has_bit(0);
+}
+inline void RPCHeader_ErrorResponse::clear_error_type() {
+ error_type_ = 1;
+ _clear_bit(0);
+}
+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);
+ 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);
+}
+inline void RPCHeader_ErrorResponse::clear_posix_errno() {
+ posix_errno_ = 9999;
+ _clear_bit(1);
+}
+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);
+ posix_errno_ = value;
+}
+
+// optional string error_message = 3;
+inline bool RPCHeader_ErrorResponse::has_error_message() const {
+ return _has_bit(2);
+}
+inline void RPCHeader_ErrorResponse::clear_error_message() {
+ if (error_message_ != &_default_error_message_) {
+ error_message_->clear();
+ }
+ _clear_bit(2);
+}
+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_) {
+ 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_) {
+ 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_) {
+ 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_) {
+ error_message_ = new ::std::string;
+ }
+ return error_message_;
+}
+
+// optional string debug_info = 4;
+inline bool RPCHeader_ErrorResponse::has_debug_info() const {
+ return _has_bit(3);
+}
+inline void RPCHeader_ErrorResponse::clear_debug_info() {
+ if (debug_info_ != &_default_debug_info_) {
+ debug_info_->clear();
+ }
+ _clear_bit(3);
+}
+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_) {
+ 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_) {
+ 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_) {
+ 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_) {
+ debug_info_ = new ::std::string;
+ }
+ return debug_info_;
+}
+
+// optional string redirect_to_server_uuid = 5;
+inline bool RPCHeader_ErrorResponse::has_redirect_to_server_uuid() const {
+ return _has_bit(4);
+}
+inline void RPCHeader_ErrorResponse::clear_redirect_to_server_uuid() {
+ if (redirect_to_server_uuid_ != &_default_redirect_to_server_uuid_) {
+ redirect_to_server_uuid_->clear();
+ }
+ _clear_bit(4);
+}
+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_) {
+ 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_) {
+ 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_) {
+ 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_) {
+ redirect_to_server_uuid_ = new ::std::string;
+ }
+ return redirect_to_server_uuid_;
+}
+
+// -------------------------------------------------------------------
+
+// RPCHeader
+
+// required fixed32 call_id = 1;
+inline bool RPCHeader::has_call_id() const {
+ return _has_bit(0);
+}
+inline void RPCHeader::clear_call_id() {
+ call_id_ = 0u;
+ _clear_bit(0);
+}
+inline ::google::protobuf::uint32 RPCHeader::call_id() const {
+ return call_id_;
+}
+inline void RPCHeader::set_call_id(::google::protobuf::uint32 value) {
+ _set_bit(0);
+ call_id_ = value;
+}
+
+// required .xtreemfs.pbrpc.MessageType message_type = 2;
+inline bool RPCHeader::has_message_type() const {
+ return _has_bit(1);
+}
+inline void RPCHeader::clear_message_type() {
+ message_type_ = 0;
+ _clear_bit(1);
+}
+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);
+ message_type_ = value;
+}
+
+// optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
+inline bool RPCHeader::has_request_header() const {
+ return _has_bit(2);
+}
+inline void RPCHeader::clear_request_header() {
+ if (request_header_ != NULL) request_header_->::xtreemfs::pbrpc::RPCHeader_RequestHeader::Clear();
+ _clear_bit(2);
+}
+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);
+ if (request_header_ == NULL) request_header_ = new ::xtreemfs::pbrpc::RPCHeader_RequestHeader;
+ return request_header_;
+}
+
+// optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
+inline bool RPCHeader::has_error_response() const {
+ return _has_bit(3);
+}
+inline void RPCHeader::clear_error_response() {
+ if (error_response_ != NULL) error_response_->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::Clear();
+ _clear_bit(3);
+}
+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);
+ if (error_response_ == NULL) error_response_ = new ::xtreemfs::pbrpc::RPCHeader_ErrorResponse;
+ return error_response_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::MessageType>() {
+ return xtreemfs::pbrpc::MessageType_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::AuthType>() {
+ return xtreemfs::pbrpc::AuthType_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::ErrorType>() {
+ return xtreemfs::pbrpc::ErrorType_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::POSIXErrno>() {
+ return xtreemfs::pbrpc::POSIXErrno_descriptor();
+}
+
+} // namespace google
+} // namespace protobuf
+#endif // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif // PROTOBUF_pbrpc_2fRPC_2eproto__INCLUDED
diff --git a/cpp/generated/xtreemfs/CMakeLists.txt b/cpp/generated/xtreemfs/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/cpp/generated/xtreemfs/DIR.pb.cc b/cpp/generated/xtreemfs/DIR.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bafb18a369feaf200f1990e686bb22bf6af1b8a4
--- /dev/null
+++ b/cpp/generated/xtreemfs/DIR.pb.cc
@@ -0,0 +1,6008 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "xtreemfs/DIR.pb.h"
+#include
+#include
+#include
+#include
+#include
+#include
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+namespace {
+
+const ::google::protobuf::Descriptor* AddressMapping_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ AddressMapping_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AddressMappingSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ AddressMappingSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DirService_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ DirService_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ServiceDataMap_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ ServiceDataMap_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Service_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ Service_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ServiceSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ ServiceSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Configuration_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ Configuration_reflection_ = NULL;
+const ::google::protobuf::Descriptor* addressMappingGetRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ addressMappingGetRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* addressMappingGetResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ addressMappingGetResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* addressMappingSetResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ addressMappingSetResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* globalTimeSGetResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ globalTimeSGetResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* serviceDeregisterRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ serviceDeregisterRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* serviceGetByNameRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ serviceGetByNameRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* serviceGetByUUIDRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ serviceGetByUUIDRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* serviceGetByTypeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ serviceGetByTypeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* serviceRegisterRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ serviceRegisterRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* serviceRegisterResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ serviceRegisterResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* configurationGetRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ configurationGetRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* configurationSetResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+ configurationSetResponse_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* ServiceType_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor_ = NULL;
+const ::google::protobuf::ServiceDescriptor* DIRService_descriptor_ = NULL;
+
+} // namespace
+
+
+void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto() {
+ protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ const ::google::protobuf::FileDescriptor* file =
+ ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+ "xtreemfs/DIR.proto");
+ GOOGLE_CHECK(file != NULL);
+ AddressMapping_descriptor_ = file->message_type(0);
+ static const int AddressMapping_offsets_[8] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, uuid_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, version_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, protocol_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, address_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, port_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, match_network_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, ttl_s_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, uri_),
+ };
+ AddressMapping_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ AddressMapping_descriptor_,
+ AddressMapping::default_instance_,
+ AddressMapping_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(AddressMapping));
+ AddressMappingSet_descriptor_ = file->message_type(1);
+ static const int AddressMappingSet_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, mappings_),
+ };
+ AddressMappingSet_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ AddressMappingSet_descriptor_,
+ AddressMappingSet::default_instance_,
+ AddressMappingSet_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(AddressMappingSet));
+ DirService_descriptor_ = file->message_type(2);
+ static const int DirService_offsets_[4] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, address_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, port_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, protocol_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, interface_version_),
+ };
+ DirService_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ DirService_descriptor_,
+ DirService::default_instance_,
+ DirService_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(DirService));
+ ServiceDataMap_descriptor_ = file->message_type(3);
+ static const int ServiceDataMap_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, data_),
+ };
+ ServiceDataMap_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ ServiceDataMap_descriptor_,
+ ServiceDataMap::default_instance_,
+ ServiceDataMap_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(ServiceDataMap));
+ Service_descriptor_ = file->message_type(4);
+ static const int Service_offsets_[6] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, type_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, uuid_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, version_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, name_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, last_updated_s_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, data_),
+ };
+ Service_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ Service_descriptor_,
+ Service::default_instance_,
+ Service_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(Service));
+ ServiceSet_descriptor_ = file->message_type(5);
+ static const int ServiceSet_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, services_),
+ };
+ ServiceSet_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ ServiceSet_descriptor_,
+ ServiceSet::default_instance_,
+ ServiceSet_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(ServiceSet));
+ Configuration_descriptor_ = file->message_type(6);
+ static const int Configuration_offsets_[3] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, uuid_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, parameter_),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, version_),
+ };
+ Configuration_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ Configuration_descriptor_,
+ Configuration::default_instance_,
+ Configuration_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(Configuration));
+ addressMappingGetRequest_descriptor_ = file->message_type(7);
+ static const int addressMappingGetRequest_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, uuid_),
+ };
+ addressMappingGetRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ addressMappingGetRequest_descriptor_,
+ addressMappingGetRequest::default_instance_,
+ addressMappingGetRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(addressMappingGetRequest));
+ addressMappingGetResponse_descriptor_ = file->message_type(8);
+ static const int addressMappingGetResponse_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, result_),
+ };
+ addressMappingGetResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ addressMappingGetResponse_descriptor_,
+ addressMappingGetResponse::default_instance_,
+ addressMappingGetResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(addressMappingGetResponse));
+ addressMappingSetResponse_descriptor_ = file->message_type(9);
+ static const int addressMappingSetResponse_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, new_version_),
+ };
+ addressMappingSetResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ addressMappingSetResponse_descriptor_,
+ addressMappingSetResponse::default_instance_,
+ addressMappingSetResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(addressMappingSetResponse));
+ globalTimeSGetResponse_descriptor_ = file->message_type(10);
+ static const int globalTimeSGetResponse_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, time_in_seconds_),
+ };
+ globalTimeSGetResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ globalTimeSGetResponse_descriptor_,
+ globalTimeSGetResponse::default_instance_,
+ globalTimeSGetResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(globalTimeSGetResponse));
+ serviceDeregisterRequest_descriptor_ = file->message_type(11);
+ static const int serviceDeregisterRequest_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, uuid_),
+ };
+ serviceDeregisterRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ serviceDeregisterRequest_descriptor_,
+ serviceDeregisterRequest::default_instance_,
+ serviceDeregisterRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(serviceDeregisterRequest));
+ serviceGetByNameRequest_descriptor_ = file->message_type(12);
+ static const int serviceGetByNameRequest_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, name_),
+ };
+ serviceGetByNameRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ serviceGetByNameRequest_descriptor_,
+ serviceGetByNameRequest::default_instance_,
+ serviceGetByNameRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(serviceGetByNameRequest));
+ serviceGetByUUIDRequest_descriptor_ = file->message_type(13);
+ static const int serviceGetByUUIDRequest_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, name_),
+ };
+ serviceGetByUUIDRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ serviceGetByUUIDRequest_descriptor_,
+ serviceGetByUUIDRequest::default_instance_,
+ serviceGetByUUIDRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(serviceGetByUUIDRequest));
+ serviceGetByTypeRequest_descriptor_ = file->message_type(14);
+ static const int serviceGetByTypeRequest_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, type_),
+ };
+ serviceGetByTypeRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ serviceGetByTypeRequest_descriptor_,
+ serviceGetByTypeRequest::default_instance_,
+ serviceGetByTypeRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(serviceGetByTypeRequest));
+ serviceRegisterRequest_descriptor_ = file->message_type(15);
+ static const int serviceRegisterRequest_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, service_),
+ };
+ serviceRegisterRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ serviceRegisterRequest_descriptor_,
+ serviceRegisterRequest::default_instance_,
+ serviceRegisterRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(serviceRegisterRequest));
+ serviceRegisterResponse_descriptor_ = file->message_type(16);
+ static const int serviceRegisterResponse_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, new_version_),
+ };
+ serviceRegisterResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ serviceRegisterResponse_descriptor_,
+ serviceRegisterResponse::default_instance_,
+ serviceRegisterResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(serviceRegisterResponse));
+ configurationGetRequest_descriptor_ = file->message_type(17);
+ static const int configurationGetRequest_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, uuid_),
+ };
+ configurationGetRequest_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ configurationGetRequest_descriptor_,
+ configurationGetRequest::default_instance_,
+ configurationGetRequest_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(configurationGetRequest));
+ configurationSetResponse_descriptor_ = file->message_type(18);
+ static const int configurationSetResponse_offsets_[1] = {
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, new_version_),
+ };
+ configurationSetResponse_reflection_ =
+ new ::google::protobuf::internal::GeneratedMessageReflection(
+ configurationSetResponse_descriptor_,
+ configurationSetResponse::default_instance_,
+ configurationSetResponse_offsets_,
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, _has_bits_[0]),
+ GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, _unknown_fields_),
+ -1,
+ ::google::protobuf::DescriptorPool::generated_pool(),
+ ::google::protobuf::MessageFactory::generated_factory(),
+ sizeof(configurationSetResponse));
+ ServiceType_descriptor_ = file->enum_type(0);
+ ServiceStatus_descriptor_ = file->enum_type(1);
+ DIRService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+ ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+ &protobuf_AssignDesc_xtreemfs_2fDIR_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ AddressMapping_descriptor_, &AddressMapping::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ AddressMappingSet_descriptor_, &AddressMappingSet::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ DirService_descriptor_, &DirService::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ ServiceDataMap_descriptor_, &ServiceDataMap::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ Service_descriptor_, &Service::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ ServiceSet_descriptor_, &ServiceSet::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ Configuration_descriptor_, &Configuration::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ addressMappingGetRequest_descriptor_, &addressMappingGetRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ addressMappingGetResponse_descriptor_, &addressMappingGetResponse::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ addressMappingSetResponse_descriptor_, &addressMappingSetResponse::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ globalTimeSGetResponse_descriptor_, &globalTimeSGetResponse::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ serviceDeregisterRequest_descriptor_, &serviceDeregisterRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ serviceGetByNameRequest_descriptor_, &serviceGetByNameRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ serviceGetByUUIDRequest_descriptor_, &serviceGetByUUIDRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ serviceGetByTypeRequest_descriptor_, &serviceGetByTypeRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ serviceRegisterRequest_descriptor_, &serviceRegisterRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ serviceRegisterResponse_descriptor_, &serviceRegisterResponse::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ configurationGetRequest_descriptor_, &configurationGetRequest::default_instance());
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+ configurationSetResponse_descriptor_, &configurationSetResponse::default_instance());
+}
+
+} // namespace
+
+void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto() {
+ delete AddressMapping::default_instance_;
+ delete AddressMapping_reflection_;
+ delete AddressMappingSet::default_instance_;
+ delete AddressMappingSet_reflection_;
+ delete DirService::default_instance_;
+ delete DirService_reflection_;
+ delete ServiceDataMap::default_instance_;
+ delete ServiceDataMap_reflection_;
+ delete Service::default_instance_;
+ delete Service_reflection_;
+ delete ServiceSet::default_instance_;
+ delete ServiceSet_reflection_;
+ delete Configuration::default_instance_;
+ delete Configuration_reflection_;
+ delete addressMappingGetRequest::default_instance_;
+ delete addressMappingGetRequest_reflection_;
+ delete addressMappingGetResponse::default_instance_;
+ delete addressMappingGetResponse_reflection_;
+ delete addressMappingSetResponse::default_instance_;
+ delete addressMappingSetResponse_reflection_;
+ delete globalTimeSGetResponse::default_instance_;
+ delete globalTimeSGetResponse_reflection_;
+ delete serviceDeregisterRequest::default_instance_;
+ delete serviceDeregisterRequest_reflection_;
+ delete serviceGetByNameRequest::default_instance_;
+ delete serviceGetByNameRequest_reflection_;
+ delete serviceGetByUUIDRequest::default_instance_;
+ delete serviceGetByUUIDRequest_reflection_;
+ delete serviceGetByTypeRequest::default_instance_;
+ delete serviceGetByTypeRequest_reflection_;
+ delete serviceRegisterRequest::default_instance_;
+ delete serviceRegisterRequest_reflection_;
+ delete serviceRegisterResponse::default_instance_;
+ delete serviceRegisterResponse_reflection_;
+ delete configurationGetRequest::default_instance_;
+ delete configurationGetRequest_reflection_;
+ delete configurationSetResponse::default_instance_;
+ delete configurationSetResponse_reflection_;
+}
+
+void protobuf_AddDesc_xtreemfs_2fDIR_2eproto() {
+ static bool already_here = false;
+ if (already_here) return;
+ already_here = true;
+ GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+ ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fPBRPC_2eproto();
+ ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fCommon_2eproto();
+ ::xtreemfs::pbrpc::protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
+ ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+ "\n\022xtreemfs/DIR.proto\022\016xtreemfs.pbrpc\032\023in"
+ "clude/PBRPC.proto\032\024include/Common.proto\032"
+ "\032xtreemfs/GlobalTypes.proto\"\223\001\n\016AddressM"
+ "apping\022\014\n\004uuid\030\001 \002(\t\022\017\n\007version\030\002 \002(\006\022\020\n"
+ "\010protocol\030\003 \002(\t\022\017\n\007address\030\004 \002(\t\022\014\n\004port"
+ "\030\005 \002(\007\022\025\n\rmatch_network\030\006 \002(\t\022\r\n\005ttl_s\030\007"
+ " \002(\007\022\013\n\003uri\030\010 \002(\t\"E\n\021AddressMappingSet\0220"
+ "\n\010mappings\030\001 \003(\0132\036.xtreemfs.pbrpc.Addres"
+ "sMapping\"X\n\nDirService\022\017\n\007address\030\001 \002(\t\022"
+ "\014\n\004port\030\002 \002(\007\022\020\n\010protocol\030\003 \002(\t\022\031\n\021inter"
+ "face_version\030\004 \002(\007\"<\n\016ServiceDataMap\022*\n\004"
+ "data\030\001 \003(\0132\034.xtreemfs.pbrpc.KeyValuePair"
+ "\"\247\001\n\007Service\022)\n\004type\030\001 \002(\0162\033.xtreemfs.pb"
+ "rpc.ServiceType\022\014\n\004uuid\030\002 \002(\t\022\017\n\007version"
+ "\030\003 \002(\006\022\014\n\004name\030\004 \002(\t\022\026\n\016last_updated_s\030\005"
+ " \002(\006\022,\n\004data\030\006 \002(\0132\036.xtreemfs.pbrpc.Serv"
+ "iceDataMap\"7\n\nServiceSet\022)\n\010services\030\001 \003"
+ "(\0132\027.xtreemfs.pbrpc.Service\"_\n\rConfigura"
+ "tion\022\014\n\004uuid\030\001 \002(\t\022/\n\tparameter\030\002 \003(\0132\034."
+ "xtreemfs.pbrpc.KeyValuePair\022\017\n\007version\030\003"
+ " \002(\006\"(\n\030addressMappingGetRequest\022\014\n\004uuid"
+ "\030\001 \002(\t\"N\n\031addressMappingGetResponse\0221\n\006r"
+ "esult\030\001 \001(\0132!.xtreemfs.pbrpc.AddressMapp"
+ "ingSet\"0\n\031addressMappingSetResponse\022\023\n\013n"
+ "ew_version\030\001 \001(\006\"1\n\026globalTimeSGetRespon"
+ "se\022\027\n\017time_in_seconds\030\001 \002(\006\"(\n\030serviceDe"
+ "registerRequest\022\014\n\004uuid\030\001 \002(\t\"\'\n\027service"
+ "GetByNameRequest\022\014\n\004name\030\001 \002(\t\"\'\n\027servic"
+ "eGetByUUIDRequest\022\014\n\004name\030\001 \002(\t\"D\n\027servi"
+ "ceGetByTypeRequest\022)\n\004type\030\001 \002(\0162\033.xtree"
+ "mfs.pbrpc.ServiceType\"B\n\026serviceRegister"
+ "Request\022(\n\007service\030\001 \002(\0132\027.xtreemfs.pbrp"
+ "c.Service\".\n\027serviceRegisterResponse\022\023\n\013"
+ "new_version\030\001 \002(\006\"\'\n\027configurationGetReq"
+ "uest\022\014\n\004uuid\030\001 \002(\t\"/\n\030configurationSetRe"
+ "sponse\022\023\n\013new_version\030\001 \001(\006*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\371\014\n\nDIRService\022u\n\035xtreemfs_address_mapp"
+ "ings_get\022(.xtreemfs.pbrpc.addressMapping"
+ "GetRequest\032!.xtreemfs.pbrpc.AddressMappi"
+ "ngSet\"\007\215\265\030\001\000\000\000\022t\n xtreemfs_address_mappi"
+ "ngs_remove\022(.xtreemfs.pbrpc.addressMappi"
+ "ngGetRequest\032\035.xtreemfs.pbrpc.emptyRespo"
+ "nse\"\007\215\265\030\002\000\000\000\022v\n\035xtreemfs_address_mapping"
+ "s_set\022!.xtreemfs.pbrpc.AddressMappingSet"
+ "\032).xtreemfs.pbrpc.addressMappingSetRespo"
+ "nse\"\007\215\265\030\003\000\000\000\022Z\n\025xtreemfs_discover_dir\022\034."
+ "xtreemfs.pbrpc.emptyRequest\032\032.xtreemfs.p"
+ "brpc.DirService\"\007\215\265\030\004\000\000\000\022k\n\032xtreemfs_glo"
+ "bal_time_s_get\022\034.xtreemfs.pbrpc.emptyReq"
+ "uest\032&.xtreemfs.pbrpc.globalTimeSGetResp"
+ "onse\"\007\215\265\030\005\000\000\000\022o\n\033xtreemfs_service_deregi"
+ "ster\022(.xtreemfs.pbrpc.serviceDeregisterR"
+ "equest\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215"
+ "\265\030\006\000\000\000\022l\n\034xtreemfs_service_get_by_name\022\'"
+ ".xtreemfs.pbrpc.serviceGetByNameRequest\032"
+ "\032.xtreemfs.pbrpc.ServiceSet\"\007\215\265\030\007\000\000\000\022l\n\034"
+ "xtreemfs_service_get_by_type\022\'.xtreemfs."
+ "pbrpc.serviceGetByTypeRequest\032\032.xtreemfs"
+ ".pbrpc.ServiceSet\"\007\215\265\030\010\000\000\000\022l\n\034xtreemfs_s"
+ "ervice_get_by_uuid\022\'.xtreemfs.pbrpc.serv"
+ "iceGetByUUIDRequest\032\032.xtreemfs.pbrpc.Ser"
+ "viceSet\"\007\215\265\030\t\000\000\000\022k\n\030xtreemfs_service_off"
+ "line\022\'.xtreemfs.pbrpc.serviceGetByUUIDRe"
+ "quest\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265"
+ "\030\n\000\000\000\022u\n\031xtreemfs_service_register\022&.xtr"
+ "eemfs.pbrpc.serviceRegisterRequest\032\'.xtr"
+ "eemfs.pbrpc.serviceRegisterResponse\"\007\215\265\030"
+ "\013\000\000\000\022[\n\023xtreemfs_checkpoint\022\034.xtreemfs.p"
+ "brpc.emptyRequest\032\035.xtreemfs.pbrpc.empty"
+ "Response\"\007\215\265\030\024\000\000\000\022Y\n\021xtreemfs_shutdown\022\034"
+ ".xtreemfs.pbrpc.emptyRequest\032\035.xtreemfs."
+ "pbrpc.emptyResponse\"\007\215\265\030\025\000\000\000\022m\n\032xtreemfs"
+ "_configuration_get\022\'.xtreemfs.pbrpc.conf"
+ "igurationGetRequest\032\035.xtreemfs.pbrpc.Con"
+ "figuration\"\007\215\265\030\026\000\000\000\022n\n\032xtreemfs_configur"
+ "ation_set\022\035.xtreemfs.pbrpc.Configuration"
+ "\032(.xtreemfs.pbrpc.configurationSetRespon"
+ "se\"\007\215\265\030\027\000\000\000\032\007\225\265\030\021\'\000\000B(\n&org.xtreemfs.pbr"
+ "pc.generatedinterfaces", 3342);
+ ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+ "xtreemfs/DIR.proto", &protobuf_RegisterTypes);
+ AddressMapping::default_instance_ = new AddressMapping();
+ AddressMappingSet::default_instance_ = new AddressMappingSet();
+ DirService::default_instance_ = new DirService();
+ ServiceDataMap::default_instance_ = new ServiceDataMap();
+ Service::default_instance_ = new Service();
+ ServiceSet::default_instance_ = new ServiceSet();
+ Configuration::default_instance_ = new Configuration();
+ addressMappingGetRequest::default_instance_ = new addressMappingGetRequest();
+ addressMappingGetResponse::default_instance_ = new addressMappingGetResponse();
+ addressMappingSetResponse::default_instance_ = new addressMappingSetResponse();
+ globalTimeSGetResponse::default_instance_ = new globalTimeSGetResponse();
+ serviceDeregisterRequest::default_instance_ = new serviceDeregisterRequest();
+ serviceGetByNameRequest::default_instance_ = new serviceGetByNameRequest();
+ serviceGetByUUIDRequest::default_instance_ = new serviceGetByUUIDRequest();
+ serviceGetByTypeRequest::default_instance_ = new serviceGetByTypeRequest();
+ serviceRegisterRequest::default_instance_ = new serviceRegisterRequest();
+ serviceRegisterResponse::default_instance_ = new serviceRegisterResponse();
+ configurationGetRequest::default_instance_ = new configurationGetRequest();
+ configurationSetResponse::default_instance_ = new configurationSetResponse();
+ AddressMapping::default_instance_->InitAsDefaultInstance();
+ AddressMappingSet::default_instance_->InitAsDefaultInstance();
+ DirService::default_instance_->InitAsDefaultInstance();
+ ServiceDataMap::default_instance_->InitAsDefaultInstance();
+ Service::default_instance_->InitAsDefaultInstance();
+ ServiceSet::default_instance_->InitAsDefaultInstance();
+ Configuration::default_instance_->InitAsDefaultInstance();
+ addressMappingGetRequest::default_instance_->InitAsDefaultInstance();
+ addressMappingGetResponse::default_instance_->InitAsDefaultInstance();
+ addressMappingSetResponse::default_instance_->InitAsDefaultInstance();
+ globalTimeSGetResponse::default_instance_->InitAsDefaultInstance();
+ serviceDeregisterRequest::default_instance_->InitAsDefaultInstance();
+ serviceGetByNameRequest::default_instance_->InitAsDefaultInstance();
+ serviceGetByUUIDRequest::default_instance_->InitAsDefaultInstance();
+ serviceGetByTypeRequest::default_instance_->InitAsDefaultInstance();
+ serviceRegisterRequest::default_instance_->InitAsDefaultInstance();
+ serviceRegisterResponse::default_instance_->InitAsDefaultInstance();
+ configurationGetRequest::default_instance_->InitAsDefaultInstance();
+ configurationSetResponse::default_instance_->InitAsDefaultInstance();
+ ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_xtreemfs_2fDIR_2eproto {
+ StaticDescriptorInitializer_xtreemfs_2fDIR_2eproto() {
+ protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+ }
+} static_descriptor_initializer_xtreemfs_2fDIR_2eproto_;
+
+const ::google::protobuf::EnumDescriptor* ServiceType_descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return ServiceType_descriptor_;
+}
+bool ServiceType_IsValid(int value) {
+ switch(value) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ return true;
+ default:
+ return false;
+ }
+}
+
+const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return ServiceStatus_descriptor_;
+}
+bool ServiceStatus_IsValid(int value) {
+ switch(value) {
+ case 0:
+ case 1:
+ case 2:
+ return true;
+ default:
+ return false;
+ }
+}
+
+
+// ===================================================================
+
+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;
+const int AddressMapping::kProtocolFieldNumber;
+const int AddressMapping::kAddressFieldNumber;
+const int AddressMapping::kPortFieldNumber;
+const int AddressMapping::kMatchNetworkFieldNumber;
+const int AddressMapping::kTtlSFieldNumber;
+const int AddressMapping::kUriFieldNumber;
+#endif // !_MSC_VER
+
+AddressMapping::AddressMapping()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void AddressMapping::InitAsDefaultInstance() {
+}
+
+AddressMapping::AddressMapping(const AddressMapping& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void AddressMapping::SharedCtor() {
+ _cached_size_ = 0;
+ uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ version_ = GOOGLE_ULONGLONG(0);
+ protocol_ = const_cast< ::std::string*>(&_default_protocol_);
+ address_ = const_cast< ::std::string*>(&_default_address_);
+ port_ = 0u;
+ match_network_ = const_cast< ::std::string*>(&_default_match_network_);
+ ttl_s_ = 0u;
+ uri_ = const_cast< ::std::string*>(&_default_uri_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AddressMapping::~AddressMapping() {
+ SharedDtor();
+}
+
+void AddressMapping::SharedDtor() {
+ if (uuid_ != &_default_uuid_) {
+ delete uuid_;
+ }
+ if (protocol_ != &_default_protocol_) {
+ delete protocol_;
+ }
+ if (address_ != &_default_address_) {
+ delete address_;
+ }
+ if (match_network_ != &_default_match_network_) {
+ delete match_network_;
+ }
+ if (uri_ != &_default_uri_) {
+ delete uri_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void AddressMapping::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AddressMapping::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return AddressMapping_descriptor_;
+}
+
+const AddressMapping& AddressMapping::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+AddressMapping* AddressMapping::default_instance_ = NULL;
+
+AddressMapping* AddressMapping::New() const {
+ return new AddressMapping;
+}
+
+void AddressMapping::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ }
+ version_ = GOOGLE_ULONGLONG(0);
+ if (_has_bit(2)) {
+ if (protocol_ != &_default_protocol_) {
+ protocol_->clear();
+ }
+ }
+ if (_has_bit(3)) {
+ if (address_ != &_default_address_) {
+ address_->clear();
+ }
+ }
+ port_ = 0u;
+ if (_has_bit(5)) {
+ if (match_network_ != &_default_match_network_) {
+ match_network_->clear();
+ }
+ }
+ ttl_s_ = 0u;
+ if (_has_bit(7)) {
+ if (uri_ != &_default_uri_) {
+ uri_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool AddressMapping::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string uuid = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_uuid()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(17)) goto parse_version;
+ break;
+ }
+
+ // required fixed64 version = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+ parse_version:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+ input, &version_)));
+ _set_bit(1);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(26)) goto parse_protocol;
+ break;
+ }
+
+ // required string protocol = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_protocol:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_protocol()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->protocol().data(), this->protocol().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(34)) goto parse_address;
+ break;
+ }
+
+ // required string address = 4;
+ case 4: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_address:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_address()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->address().data(), this->address().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(45)) goto parse_port;
+ break;
+ }
+
+ // required fixed32 port = 5;
+ case 5: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+ parse_port:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+ input, &port_)));
+ _set_bit(4);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(50)) goto parse_match_network;
+ break;
+ }
+
+ // required string match_network = 6;
+ case 6: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_match_network:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_match_network()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->match_network().data(), this->match_network().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(61)) goto parse_ttl_s;
+ break;
+ }
+
+ // required fixed32 ttl_s = 7;
+ case 7: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+ parse_ttl_s:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+ input, &ttl_s_)));
+ _set_bit(6);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(66)) goto parse_uri;
+ break;
+ }
+
+ // required string uri = 8;
+ case 8: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_uri:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_uri()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uri().data(), this->uri().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void AddressMapping::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->version(), output);
+ }
+
+ // required string protocol = 3;
+ if (_has_bit(2)) {
+ ::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)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->port(), output);
+ }
+
+ // required string match_network = 6;
+ if (_has_bit(5)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed32(7, this->ttl_s(), output);
+ }
+
+ // required string uri = 8;
+ if (_has_bit(7)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uri().data(), this->uri().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 8, this->uri(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* AddressMapping::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->uuid(), target);
+ }
+
+ // required fixed64 version = 2;
+ if (_has_bit(1)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->version(), target);
+ }
+
+ // required string protocol = 3;
+ if (_has_bit(2)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->protocol().data(), this->protocol().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 3, this->protocol(), target);
+ }
+
+ // required string address = 4;
+ if (_has_bit(3)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->address().data(), this->address().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 4, this->address(), target);
+ }
+
+ // required fixed32 port = 5;
+ if (_has_bit(4)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->port(), target);
+ }
+
+ // required string match_network = 6;
+ if (_has_bit(5)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->match_network().data(), this->match_network().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 6, this->match_network(), target);
+ }
+
+ // required fixed32 ttl_s = 7;
+ if (_has_bit(6)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(7, this->ttl_s(), target);
+ }
+
+ // required string uri = 8;
+ if (_has_bit(7)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uri().data(), this->uri().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 8, this->uri(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int AddressMapping::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string uuid = 1;
+ if (has_uuid()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->uuid());
+ }
+
+ // required fixed64 version = 2;
+ if (has_version()) {
+ total_size += 1 + 8;
+ }
+
+ // required string protocol = 3;
+ if (has_protocol()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->protocol());
+ }
+
+ // required string address = 4;
+ if (has_address()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->address());
+ }
+
+ // required fixed32 port = 5;
+ if (has_port()) {
+ total_size += 1 + 4;
+ }
+
+ // required string match_network = 6;
+ if (has_match_network()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->match_network());
+ }
+
+ // required fixed32 ttl_s = 7;
+ if (has_ttl_s()) {
+ total_size += 1 + 4;
+ }
+
+ // required string uri = 8;
+ if (has_uri()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->uri());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void AddressMapping::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const AddressMapping* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void AddressMapping::MergeFrom(const AddressMapping& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_uuid(from.uuid());
+ }
+ if (from._has_bit(1)) {
+ set_version(from.version());
+ }
+ if (from._has_bit(2)) {
+ set_protocol(from.protocol());
+ }
+ if (from._has_bit(3)) {
+ set_address(from.address());
+ }
+ if (from._has_bit(4)) {
+ set_port(from.port());
+ }
+ if (from._has_bit(5)) {
+ set_match_network(from.match_network());
+ }
+ if (from._has_bit(6)) {
+ set_ttl_s(from.ttl_s());
+ }
+ if (from._has_bit(7)) {
+ set_uri(from.uri());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AddressMapping::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void AddressMapping::CopyFrom(const AddressMapping& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool AddressMapping::IsInitialized() const {
+ if ((_has_bits_[0] & 0x000000ff) != 0x000000ff) return false;
+
+ return true;
+}
+
+void AddressMapping::Swap(AddressMapping* other) {
+ if (other != this) {
+ std::swap(uuid_, other->uuid_);
+ std::swap(version_, other->version_);
+ std::swap(protocol_, other->protocol_);
+ std::swap(address_, other->address_);
+ std::swap(port_, other->port_);
+ std::swap(match_network_, other->match_network_);
+ std::swap(ttl_s_, other->ttl_s_);
+ std::swap(uri_, other->uri_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata AddressMapping::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = AddressMapping_descriptor_;
+ metadata.reflection = AddressMapping_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AddressMappingSet::kMappingsFieldNumber;
+#endif // !_MSC_VER
+
+AddressMappingSet::AddressMappingSet()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void AddressMappingSet::InitAsDefaultInstance() {
+}
+
+AddressMappingSet::AddressMappingSet(const AddressMappingSet& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void AddressMappingSet::SharedCtor() {
+ _cached_size_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AddressMappingSet::~AddressMappingSet() {
+ SharedDtor();
+}
+
+void AddressMappingSet::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void AddressMappingSet::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AddressMappingSet::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return AddressMappingSet_descriptor_;
+}
+
+const AddressMappingSet& AddressMappingSet::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+AddressMappingSet* AddressMappingSet::default_instance_ = NULL;
+
+AddressMappingSet* AddressMappingSet::New() const {
+ return new AddressMappingSet;
+}
+
+void AddressMappingSet::Clear() {
+ mappings_.Clear();
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool AddressMappingSet::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_mappings:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, add_mappings()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(10)) goto parse_mappings;
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void AddressMappingSet::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
+ for (int i = 0; i < this->mappings_size(); i++) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 1, this->mappings(i), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* AddressMappingSet::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
+ for (int i = 0; i < this->mappings_size(); i++) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 1, this->mappings(i), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int AddressMappingSet::ByteSize() const {
+ int total_size = 0;
+
+ // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
+ total_size += 1 * this->mappings_size();
+ for (int i = 0; i < this->mappings_size(); i++) {
+ total_size +=
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->mappings(i));
+ }
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void AddressMappingSet::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const AddressMappingSet* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void AddressMappingSet::MergeFrom(const AddressMappingSet& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ mappings_.MergeFrom(from.mappings_);
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AddressMappingSet::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void AddressMappingSet::CopyFrom(const AddressMappingSet& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool AddressMappingSet::IsInitialized() const {
+
+ for (int i = 0; i < mappings_size(); i++) {
+ if (!this->mappings(i).IsInitialized()) return false;
+ }
+ return true;
+}
+
+void AddressMappingSet::Swap(AddressMappingSet* other) {
+ if (other != this) {
+ mappings_.Swap(&other->mappings_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata AddressMappingSet::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = AddressMappingSet_descriptor_;
+ metadata.reflection = AddressMappingSet_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string DirService::_default_address_;
+const ::std::string DirService::_default_protocol_;
+#ifndef _MSC_VER
+const int DirService::kAddressFieldNumber;
+const int DirService::kPortFieldNumber;
+const int DirService::kProtocolFieldNumber;
+const int DirService::kInterfaceVersionFieldNumber;
+#endif // !_MSC_VER
+
+DirService::DirService()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void DirService::InitAsDefaultInstance() {
+}
+
+DirService::DirService(const DirService& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void DirService::SharedCtor() {
+ _cached_size_ = 0;
+ address_ = const_cast< ::std::string*>(&_default_address_);
+ port_ = 0u;
+ protocol_ = const_cast< ::std::string*>(&_default_protocol_);
+ interface_version_ = 0u;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DirService::~DirService() {
+ SharedDtor();
+}
+
+void DirService::SharedDtor() {
+ if (address_ != &_default_address_) {
+ delete address_;
+ }
+ if (protocol_ != &_default_protocol_) {
+ delete protocol_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void DirService::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DirService::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return DirService_descriptor_;
+}
+
+const DirService& DirService::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+DirService* DirService::default_instance_ = NULL;
+
+DirService* DirService::New() const {
+ return new DirService;
+}
+
+void DirService::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (address_ != &_default_address_) {
+ address_->clear();
+ }
+ }
+ port_ = 0u;
+ if (_has_bit(2)) {
+ if (protocol_ != &_default_protocol_) {
+ protocol_->clear();
+ }
+ }
+ interface_version_ = 0u;
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool DirService::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string address = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_address()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->address().data(), this->address().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(21)) goto parse_port;
+ break;
+ }
+
+ // required fixed32 port = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+ parse_port:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+ input, &port_)));
+ _set_bit(1);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(26)) goto parse_protocol;
+ break;
+ }
+
+ // required string protocol = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_protocol:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_protocol()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->protocol().data(), this->protocol().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(37)) goto parse_interface_version;
+ break;
+ }
+
+ // required fixed32 interface_version = 4;
+ case 4: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+ parse_interface_version:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+ input, &interface_version_)));
+ _set_bit(3);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void DirService::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string address = 1;
+ if (_has_bit(0)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->port(), output);
+ }
+
+ // required string protocol = 3;
+ if (_has_bit(2)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->interface_version(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* DirService::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string address = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->address().data(), this->address().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->address(), target);
+ }
+
+ // required fixed32 port = 2;
+ if (_has_bit(1)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->port(), target);
+ }
+
+ // required string protocol = 3;
+ if (_has_bit(2)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->protocol().data(), this->protocol().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 3, this->protocol(), target);
+ }
+
+ // required fixed32 interface_version = 4;
+ if (_has_bit(3)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->interface_version(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int DirService::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string address = 1;
+ if (has_address()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->address());
+ }
+
+ // required fixed32 port = 2;
+ if (has_port()) {
+ total_size += 1 + 4;
+ }
+
+ // required string protocol = 3;
+ if (has_protocol()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->protocol());
+ }
+
+ // required fixed32 interface_version = 4;
+ if (has_interface_version()) {
+ total_size += 1 + 4;
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void DirService::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const DirService* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void DirService::MergeFrom(const DirService& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_address(from.address());
+ }
+ if (from._has_bit(1)) {
+ set_port(from.port());
+ }
+ if (from._has_bit(2)) {
+ set_protocol(from.protocol());
+ }
+ if (from._has_bit(3)) {
+ set_interface_version(from.interface_version());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DirService::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void DirService::CopyFrom(const DirService& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool DirService::IsInitialized() const {
+ if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
+
+ return true;
+}
+
+void DirService::Swap(DirService* other) {
+ if (other != this) {
+ std::swap(address_, other->address_);
+ std::swap(port_, other->port_);
+ std::swap(protocol_, other->protocol_);
+ std::swap(interface_version_, other->interface_version_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata DirService::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = DirService_descriptor_;
+ metadata.reflection = DirService_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ServiceDataMap::kDataFieldNumber;
+#endif // !_MSC_VER
+
+ServiceDataMap::ServiceDataMap()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void ServiceDataMap::InitAsDefaultInstance() {
+}
+
+ServiceDataMap::ServiceDataMap(const ServiceDataMap& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void ServiceDataMap::SharedCtor() {
+ _cached_size_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ServiceDataMap::~ServiceDataMap() {
+ SharedDtor();
+}
+
+void ServiceDataMap::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void ServiceDataMap::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ServiceDataMap::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return ServiceDataMap_descriptor_;
+}
+
+const ServiceDataMap& ServiceDataMap::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+ServiceDataMap* ServiceDataMap::default_instance_ = NULL;
+
+ServiceDataMap* ServiceDataMap::New() const {
+ return new ServiceDataMap;
+}
+
+void ServiceDataMap::Clear() {
+ data_.Clear();
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool ServiceDataMap::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_data:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, add_data()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(10)) goto parse_data;
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void ServiceDataMap::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
+ for (int i = 0; i < this->data_size(); i++) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 1, this->data(i), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* ServiceDataMap::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
+ for (int i = 0; i < this->data_size(); i++) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 1, this->data(i), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int ServiceDataMap::ByteSize() const {
+ int total_size = 0;
+
+ // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
+ total_size += 1 * this->data_size();
+ for (int i = 0; i < this->data_size(); i++) {
+ total_size +=
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->data(i));
+ }
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void ServiceDataMap::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const ServiceDataMap* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void ServiceDataMap::MergeFrom(const ServiceDataMap& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ data_.MergeFrom(from.data_);
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ServiceDataMap::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void ServiceDataMap::CopyFrom(const ServiceDataMap& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool ServiceDataMap::IsInitialized() const {
+
+ for (int i = 0; i < data_size(); i++) {
+ if (!this->data(i).IsInitialized()) return false;
+ }
+ return true;
+}
+
+void ServiceDataMap::Swap(ServiceDataMap* other) {
+ if (other != this) {
+ data_.Swap(&other->data_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata ServiceDataMap::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = ServiceDataMap_descriptor_;
+ metadata.reflection = ServiceDataMap_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string Service::_default_uuid_;
+const ::std::string Service::_default_name_;
+#ifndef _MSC_VER
+const int Service::kTypeFieldNumber;
+const int Service::kUuidFieldNumber;
+const int Service::kVersionFieldNumber;
+const int Service::kNameFieldNumber;
+const int Service::kLastUpdatedSFieldNumber;
+const int Service::kDataFieldNumber;
+#endif // !_MSC_VER
+
+Service::Service()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void Service::InitAsDefaultInstance() {
+ data_ = const_cast< ::xtreemfs::pbrpc::ServiceDataMap*>(&::xtreemfs::pbrpc::ServiceDataMap::default_instance());
+}
+
+Service::Service(const Service& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void Service::SharedCtor() {
+ _cached_size_ = 0;
+ type_ = 0;
+ uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ version_ = GOOGLE_ULONGLONG(0);
+ name_ = const_cast< ::std::string*>(&_default_name_);
+ last_updated_s_ = GOOGLE_ULONGLONG(0);
+ data_ = NULL;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Service::~Service() {
+ SharedDtor();
+}
+
+void Service::SharedDtor() {
+ if (uuid_ != &_default_uuid_) {
+ delete uuid_;
+ }
+ if (name_ != &_default_name_) {
+ delete name_;
+ }
+ if (this != default_instance_) {
+ delete data_;
+ }
+}
+
+void Service::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Service::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return Service_descriptor_;
+}
+
+const Service& Service::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+Service* Service::default_instance_ = NULL;
+
+Service* Service::New() const {
+ return new Service;
+}
+
+void Service::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ type_ = 0;
+ if (_has_bit(1)) {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ }
+ version_ = GOOGLE_ULONGLONG(0);
+ if (_has_bit(3)) {
+ if (name_ != &_default_name_) {
+ name_->clear();
+ }
+ }
+ last_updated_s_ = GOOGLE_ULONGLONG(0);
+ if (_has_bit(5)) {
+ if (data_ != NULL) data_->::xtreemfs::pbrpc::ServiceDataMap::Clear();
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool Service::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ int value;
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+ input, &value)));
+ if (xtreemfs::pbrpc::ServiceType_IsValid(value)) {
+ set_type(static_cast< xtreemfs::pbrpc::ServiceType >(value));
+ } else {
+ mutable_unknown_fields()->AddVarint(1, value);
+ }
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(18)) goto parse_uuid;
+ break;
+ }
+
+ // required string uuid = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_uuid:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_uuid()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(25)) goto parse_version;
+ break;
+ }
+
+ // required fixed64 version = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+ parse_version:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+ input, &version_)));
+ _set_bit(2);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(34)) goto parse_name;
+ break;
+ }
+
+ // required string name = 4;
+ case 4: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_name:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_name()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->name().data(), this->name().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(41)) goto parse_last_updated_s;
+ break;
+ }
+
+ // required fixed64 last_updated_s = 5;
+ case 5: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+ parse_last_updated_s:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+ input, &last_updated_s_)));
+ _set_bit(4);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(50)) goto parse_data;
+ break;
+ }
+
+ // required .xtreemfs.pbrpc.ServiceDataMap data = 6;
+ case 6: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_data:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_data()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void Service::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteEnum(
+ 1, this->type(), output);
+ }
+
+ // required string uuid = 2;
+ if (_has_bit(1)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output);
+ }
+
+ // required string name = 4;
+ if (_has_bit(3)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed64(5, this->last_updated_s(), output);
+ }
+
+ // required .xtreemfs.pbrpc.ServiceDataMap data = 6;
+ if (_has_bit(5)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 6, this->data(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* Service::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+ 1, this->type(), target);
+ }
+
+ // required string uuid = 2;
+ if (_has_bit(1)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 2, this->uuid(), target);
+ }
+
+ // required fixed64 version = 3;
+ if (_has_bit(2)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target);
+ }
+
+ // required string name = 4;
+ if (_has_bit(3)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->name().data(), this->name().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 4, this->name(), target);
+ }
+
+ // required fixed64 last_updated_s = 5;
+ if (_has_bit(4)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(5, this->last_updated_s(), target);
+ }
+
+ // required .xtreemfs.pbrpc.ServiceDataMap data = 6;
+ if (_has_bit(5)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 6, this->data(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int Service::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ if (has_type()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+ }
+
+ // required string uuid = 2;
+ if (has_uuid()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->uuid());
+ }
+
+ // required fixed64 version = 3;
+ if (has_version()) {
+ total_size += 1 + 8;
+ }
+
+ // required string name = 4;
+ if (has_name()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->name());
+ }
+
+ // required fixed64 last_updated_s = 5;
+ if (has_last_updated_s()) {
+ total_size += 1 + 8;
+ }
+
+ // required .xtreemfs.pbrpc.ServiceDataMap data = 6;
+ if (has_data()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->data());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void Service::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const Service* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void Service::MergeFrom(const Service& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_type(from.type());
+ }
+ if (from._has_bit(1)) {
+ set_uuid(from.uuid());
+ }
+ if (from._has_bit(2)) {
+ set_version(from.version());
+ }
+ if (from._has_bit(3)) {
+ set_name(from.name());
+ }
+ if (from._has_bit(4)) {
+ set_last_updated_s(from.last_updated_s());
+ }
+ if (from._has_bit(5)) {
+ mutable_data()->::xtreemfs::pbrpc::ServiceDataMap::MergeFrom(from.data());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Service::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Service::CopyFrom(const Service& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Service::IsInitialized() const {
+ if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;
+
+ if (has_data()) {
+ if (!this->data().IsInitialized()) return false;
+ }
+ return true;
+}
+
+void Service::Swap(Service* other) {
+ if (other != this) {
+ std::swap(type_, other->type_);
+ std::swap(uuid_, other->uuid_);
+ std::swap(version_, other->version_);
+ std::swap(name_, other->name_);
+ std::swap(last_updated_s_, other->last_updated_s_);
+ std::swap(data_, other->data_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata Service::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = Service_descriptor_;
+ metadata.reflection = Service_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ServiceSet::kServicesFieldNumber;
+#endif // !_MSC_VER
+
+ServiceSet::ServiceSet()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void ServiceSet::InitAsDefaultInstance() {
+}
+
+ServiceSet::ServiceSet(const ServiceSet& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void ServiceSet::SharedCtor() {
+ _cached_size_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ServiceSet::~ServiceSet() {
+ SharedDtor();
+}
+
+void ServiceSet::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void ServiceSet::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ServiceSet::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return ServiceSet_descriptor_;
+}
+
+const ServiceSet& ServiceSet::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+ServiceSet* ServiceSet::default_instance_ = NULL;
+
+ServiceSet* ServiceSet::New() const {
+ return new ServiceSet;
+}
+
+void ServiceSet::Clear() {
+ services_.Clear();
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool ServiceSet::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // repeated .xtreemfs.pbrpc.Service services = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_services:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, add_services()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(10)) goto parse_services;
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void ServiceSet::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // repeated .xtreemfs.pbrpc.Service services = 1;
+ for (int i = 0; i < this->services_size(); i++) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 1, this->services(i), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* ServiceSet::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // repeated .xtreemfs.pbrpc.Service services = 1;
+ for (int i = 0; i < this->services_size(); i++) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 1, this->services(i), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int ServiceSet::ByteSize() const {
+ int total_size = 0;
+
+ // repeated .xtreemfs.pbrpc.Service services = 1;
+ total_size += 1 * this->services_size();
+ for (int i = 0; i < this->services_size(); i++) {
+ total_size +=
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->services(i));
+ }
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void ServiceSet::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const ServiceSet* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void ServiceSet::MergeFrom(const ServiceSet& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ services_.MergeFrom(from.services_);
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ServiceSet::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void ServiceSet::CopyFrom(const ServiceSet& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool ServiceSet::IsInitialized() const {
+
+ for (int i = 0; i < services_size(); i++) {
+ if (!this->services(i).IsInitialized()) return false;
+ }
+ return true;
+}
+
+void ServiceSet::Swap(ServiceSet* other) {
+ if (other != this) {
+ services_.Swap(&other->services_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata ServiceSet::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = ServiceSet_descriptor_;
+ metadata.reflection = ServiceSet_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string Configuration::_default_uuid_;
+#ifndef _MSC_VER
+const int Configuration::kUuidFieldNumber;
+const int Configuration::kParameterFieldNumber;
+const int Configuration::kVersionFieldNumber;
+#endif // !_MSC_VER
+
+Configuration::Configuration()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void Configuration::InitAsDefaultInstance() {
+}
+
+Configuration::Configuration(const Configuration& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void Configuration::SharedCtor() {
+ _cached_size_ = 0;
+ uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ version_ = GOOGLE_ULONGLONG(0);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Configuration::~Configuration() {
+ SharedDtor();
+}
+
+void Configuration::SharedDtor() {
+ if (uuid_ != &_default_uuid_) {
+ delete uuid_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void Configuration::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Configuration::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return Configuration_descriptor_;
+}
+
+const Configuration& Configuration::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+Configuration* Configuration::default_instance_ = NULL;
+
+Configuration* Configuration::New() const {
+ return new Configuration;
+}
+
+void Configuration::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ }
+ version_ = GOOGLE_ULONGLONG(0);
+ }
+ parameter_.Clear();
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool Configuration::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string uuid = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_uuid()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(18)) goto parse_parameter;
+ break;
+ }
+
+ // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_parameter:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, add_parameter()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(18)) goto parse_parameter;
+ if (input->ExpectTag(25)) goto parse_version;
+ break;
+ }
+
+ // required fixed64 version = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+ parse_version:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+ input, &version_)));
+ _set_bit(2);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void Configuration::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::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)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* Configuration::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->uuid(), target);
+ }
+
+ // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
+ for (int i = 0; i < this->parameter_size(); i++) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 2, this->parameter(i), target);
+ }
+
+ // required fixed64 version = 3;
+ if (_has_bit(2)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int Configuration::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string uuid = 1;
+ if (has_uuid()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->uuid());
+ }
+
+ // required fixed64 version = 3;
+ if (has_version()) {
+ total_size += 1 + 8;
+ }
+
+ }
+ // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
+ total_size += 1 * this->parameter_size();
+ for (int i = 0; i < this->parameter_size(); i++) {
+ total_size +=
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->parameter(i));
+ }
+
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void Configuration::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const Configuration* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void Configuration::MergeFrom(const Configuration& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ parameter_.MergeFrom(from.parameter_);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_uuid(from.uuid());
+ }
+ if (from._has_bit(2)) {
+ set_version(from.version());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Configuration::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void Configuration::CopyFrom(const Configuration& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool Configuration::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
+
+ for (int i = 0; i < parameter_size(); i++) {
+ if (!this->parameter(i).IsInitialized()) return false;
+ }
+ return true;
+}
+
+void Configuration::Swap(Configuration* other) {
+ if (other != this) {
+ std::swap(uuid_, other->uuid_);
+ parameter_.Swap(&other->parameter_);
+ std::swap(version_, other->version_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata Configuration::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = Configuration_descriptor_;
+ metadata.reflection = Configuration_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string addressMappingGetRequest::_default_uuid_;
+#ifndef _MSC_VER
+const int addressMappingGetRequest::kUuidFieldNumber;
+#endif // !_MSC_VER
+
+addressMappingGetRequest::addressMappingGetRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void addressMappingGetRequest::InitAsDefaultInstance() {
+}
+
+addressMappingGetRequest::addressMappingGetRequest(const addressMappingGetRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void addressMappingGetRequest::SharedCtor() {
+ _cached_size_ = 0;
+ uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+addressMappingGetRequest::~addressMappingGetRequest() {
+ SharedDtor();
+}
+
+void addressMappingGetRequest::SharedDtor() {
+ if (uuid_ != &_default_uuid_) {
+ delete uuid_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void addressMappingGetRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* addressMappingGetRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return addressMappingGetRequest_descriptor_;
+}
+
+const addressMappingGetRequest& addressMappingGetRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+addressMappingGetRequest* addressMappingGetRequest::default_instance_ = NULL;
+
+addressMappingGetRequest* addressMappingGetRequest::New() const {
+ return new addressMappingGetRequest;
+}
+
+void addressMappingGetRequest::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool addressMappingGetRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string uuid = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_uuid()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void addressMappingGetRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->uuid(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* addressMappingGetRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->uuid(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int addressMappingGetRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string uuid = 1;
+ if (has_uuid()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->uuid());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void addressMappingGetRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const addressMappingGetRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void addressMappingGetRequest::MergeFrom(const addressMappingGetRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_uuid(from.uuid());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void addressMappingGetRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void addressMappingGetRequest::CopyFrom(const addressMappingGetRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool addressMappingGetRequest::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void addressMappingGetRequest::Swap(addressMappingGetRequest* other) {
+ if (other != this) {
+ std::swap(uuid_, other->uuid_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata addressMappingGetRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = addressMappingGetRequest_descriptor_;
+ metadata.reflection = addressMappingGetRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int addressMappingGetResponse::kResultFieldNumber;
+#endif // !_MSC_VER
+
+addressMappingGetResponse::addressMappingGetResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void addressMappingGetResponse::InitAsDefaultInstance() {
+ result_ = const_cast< ::xtreemfs::pbrpc::AddressMappingSet*>(&::xtreemfs::pbrpc::AddressMappingSet::default_instance());
+}
+
+addressMappingGetResponse::addressMappingGetResponse(const addressMappingGetResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void addressMappingGetResponse::SharedCtor() {
+ _cached_size_ = 0;
+ result_ = NULL;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+addressMappingGetResponse::~addressMappingGetResponse() {
+ SharedDtor();
+}
+
+void addressMappingGetResponse::SharedDtor() {
+ if (this != default_instance_) {
+ delete result_;
+ }
+}
+
+void addressMappingGetResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* addressMappingGetResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return addressMappingGetResponse_descriptor_;
+}
+
+const addressMappingGetResponse& addressMappingGetResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+addressMappingGetResponse* addressMappingGetResponse::default_instance_ = NULL;
+
+addressMappingGetResponse* addressMappingGetResponse::New() const {
+ return new addressMappingGetResponse;
+}
+
+void addressMappingGetResponse::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (result_ != NULL) result_->::xtreemfs::pbrpc::AddressMappingSet::Clear();
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool addressMappingGetResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_result()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void addressMappingGetResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 1, this->result(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* addressMappingGetResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 1, this->result(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int addressMappingGetResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
+ if (has_result()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->result());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void addressMappingGetResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const addressMappingGetResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void addressMappingGetResponse::MergeFrom(const addressMappingGetResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ mutable_result()->::xtreemfs::pbrpc::AddressMappingSet::MergeFrom(from.result());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void addressMappingGetResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void addressMappingGetResponse::CopyFrom(const addressMappingGetResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool addressMappingGetResponse::IsInitialized() const {
+
+ if (has_result()) {
+ if (!this->result().IsInitialized()) return false;
+ }
+ return true;
+}
+
+void addressMappingGetResponse::Swap(addressMappingGetResponse* other) {
+ if (other != this) {
+ std::swap(result_, other->result_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata addressMappingGetResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = addressMappingGetResponse_descriptor_;
+ metadata.reflection = addressMappingGetResponse_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int addressMappingSetResponse::kNewVersionFieldNumber;
+#endif // !_MSC_VER
+
+addressMappingSetResponse::addressMappingSetResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void addressMappingSetResponse::InitAsDefaultInstance() {
+}
+
+addressMappingSetResponse::addressMappingSetResponse(const addressMappingSetResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void addressMappingSetResponse::SharedCtor() {
+ _cached_size_ = 0;
+ new_version_ = GOOGLE_ULONGLONG(0);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+addressMappingSetResponse::~addressMappingSetResponse() {
+ SharedDtor();
+}
+
+void addressMappingSetResponse::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void addressMappingSetResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* addressMappingSetResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return addressMappingSetResponse_descriptor_;
+}
+
+const addressMappingSetResponse& addressMappingSetResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+addressMappingSetResponse* addressMappingSetResponse::default_instance_ = NULL;
+
+addressMappingSetResponse* addressMappingSetResponse::New() const {
+ return new addressMappingSetResponse;
+}
+
+void addressMappingSetResponse::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ new_version_ = GOOGLE_ULONGLONG(0);
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool addressMappingSetResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // optional fixed64 new_version = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+ input, &new_version_)));
+ _set_bit(0);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void addressMappingSetResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // optional fixed64 new_version = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* addressMappingSetResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // optional fixed64 new_version = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int addressMappingSetResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // optional fixed64 new_version = 1;
+ if (has_new_version()) {
+ total_size += 1 + 8;
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void addressMappingSetResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const addressMappingSetResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void addressMappingSetResponse::MergeFrom(const addressMappingSetResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_new_version(from.new_version());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void addressMappingSetResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void addressMappingSetResponse::CopyFrom(const addressMappingSetResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool addressMappingSetResponse::IsInitialized() const {
+
+ return true;
+}
+
+void addressMappingSetResponse::Swap(addressMappingSetResponse* other) {
+ if (other != this) {
+ std::swap(new_version_, other->new_version_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata addressMappingSetResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = addressMappingSetResponse_descriptor_;
+ metadata.reflection = addressMappingSetResponse_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int globalTimeSGetResponse::kTimeInSecondsFieldNumber;
+#endif // !_MSC_VER
+
+globalTimeSGetResponse::globalTimeSGetResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void globalTimeSGetResponse::InitAsDefaultInstance() {
+}
+
+globalTimeSGetResponse::globalTimeSGetResponse(const globalTimeSGetResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void globalTimeSGetResponse::SharedCtor() {
+ _cached_size_ = 0;
+ time_in_seconds_ = GOOGLE_ULONGLONG(0);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+globalTimeSGetResponse::~globalTimeSGetResponse() {
+ SharedDtor();
+}
+
+void globalTimeSGetResponse::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void globalTimeSGetResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* globalTimeSGetResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return globalTimeSGetResponse_descriptor_;
+}
+
+const globalTimeSGetResponse& globalTimeSGetResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+globalTimeSGetResponse* globalTimeSGetResponse::default_instance_ = NULL;
+
+globalTimeSGetResponse* globalTimeSGetResponse::New() const {
+ return new globalTimeSGetResponse;
+}
+
+void globalTimeSGetResponse::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ time_in_seconds_ = GOOGLE_ULONGLONG(0);
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool globalTimeSGetResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required fixed64 time_in_seconds = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+ input, &time_in_seconds_)));
+ _set_bit(0);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void globalTimeSGetResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required fixed64 time_in_seconds = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->time_in_seconds(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* globalTimeSGetResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required fixed64 time_in_seconds = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->time_in_seconds(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int globalTimeSGetResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required fixed64 time_in_seconds = 1;
+ if (has_time_in_seconds()) {
+ total_size += 1 + 8;
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void globalTimeSGetResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const globalTimeSGetResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void globalTimeSGetResponse::MergeFrom(const globalTimeSGetResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_time_in_seconds(from.time_in_seconds());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void globalTimeSGetResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void globalTimeSGetResponse::CopyFrom(const globalTimeSGetResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool globalTimeSGetResponse::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void globalTimeSGetResponse::Swap(globalTimeSGetResponse* other) {
+ if (other != this) {
+ std::swap(time_in_seconds_, other->time_in_seconds_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata globalTimeSGetResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = globalTimeSGetResponse_descriptor_;
+ metadata.reflection = globalTimeSGetResponse_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string serviceDeregisterRequest::_default_uuid_;
+#ifndef _MSC_VER
+const int serviceDeregisterRequest::kUuidFieldNumber;
+#endif // !_MSC_VER
+
+serviceDeregisterRequest::serviceDeregisterRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void serviceDeregisterRequest::InitAsDefaultInstance() {
+}
+
+serviceDeregisterRequest::serviceDeregisterRequest(const serviceDeregisterRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void serviceDeregisterRequest::SharedCtor() {
+ _cached_size_ = 0;
+ uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+serviceDeregisterRequest::~serviceDeregisterRequest() {
+ SharedDtor();
+}
+
+void serviceDeregisterRequest::SharedDtor() {
+ if (uuid_ != &_default_uuid_) {
+ delete uuid_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void serviceDeregisterRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* serviceDeregisterRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return serviceDeregisterRequest_descriptor_;
+}
+
+const serviceDeregisterRequest& serviceDeregisterRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+serviceDeregisterRequest* serviceDeregisterRequest::default_instance_ = NULL;
+
+serviceDeregisterRequest* serviceDeregisterRequest::New() const {
+ return new serviceDeregisterRequest;
+}
+
+void serviceDeregisterRequest::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool serviceDeregisterRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string uuid = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_uuid()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void serviceDeregisterRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->uuid(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* serviceDeregisterRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->uuid(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int serviceDeregisterRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string uuid = 1;
+ if (has_uuid()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->uuid());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void serviceDeregisterRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const serviceDeregisterRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void serviceDeregisterRequest::MergeFrom(const serviceDeregisterRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_uuid(from.uuid());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void serviceDeregisterRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void serviceDeregisterRequest::CopyFrom(const serviceDeregisterRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool serviceDeregisterRequest::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void serviceDeregisterRequest::Swap(serviceDeregisterRequest* other) {
+ if (other != this) {
+ std::swap(uuid_, other->uuid_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata serviceDeregisterRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = serviceDeregisterRequest_descriptor_;
+ metadata.reflection = serviceDeregisterRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string serviceGetByNameRequest::_default_name_;
+#ifndef _MSC_VER
+const int serviceGetByNameRequest::kNameFieldNumber;
+#endif // !_MSC_VER
+
+serviceGetByNameRequest::serviceGetByNameRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void serviceGetByNameRequest::InitAsDefaultInstance() {
+}
+
+serviceGetByNameRequest::serviceGetByNameRequest(const serviceGetByNameRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void serviceGetByNameRequest::SharedCtor() {
+ _cached_size_ = 0;
+ name_ = const_cast< ::std::string*>(&_default_name_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+serviceGetByNameRequest::~serviceGetByNameRequest() {
+ SharedDtor();
+}
+
+void serviceGetByNameRequest::SharedDtor() {
+ if (name_ != &_default_name_) {
+ delete name_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void serviceGetByNameRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* serviceGetByNameRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return serviceGetByNameRequest_descriptor_;
+}
+
+const serviceGetByNameRequest& serviceGetByNameRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+serviceGetByNameRequest* serviceGetByNameRequest::default_instance_ = NULL;
+
+serviceGetByNameRequest* serviceGetByNameRequest::New() const {
+ return new serviceGetByNameRequest;
+}
+
+void serviceGetByNameRequest::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (name_ != &_default_name_) {
+ name_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool serviceGetByNameRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string name = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_name()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->name().data(), this->name().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void serviceGetByNameRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string name = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->name().data(), this->name().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->name(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* serviceGetByNameRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string name = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->name().data(), this->name().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->name(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int serviceGetByNameRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string name = 1;
+ if (has_name()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->name());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void serviceGetByNameRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const serviceGetByNameRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void serviceGetByNameRequest::MergeFrom(const serviceGetByNameRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_name(from.name());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void serviceGetByNameRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void serviceGetByNameRequest::CopyFrom(const serviceGetByNameRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool serviceGetByNameRequest::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void serviceGetByNameRequest::Swap(serviceGetByNameRequest* other) {
+ if (other != this) {
+ std::swap(name_, other->name_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata serviceGetByNameRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = serviceGetByNameRequest_descriptor_;
+ metadata.reflection = serviceGetByNameRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string serviceGetByUUIDRequest::_default_name_;
+#ifndef _MSC_VER
+const int serviceGetByUUIDRequest::kNameFieldNumber;
+#endif // !_MSC_VER
+
+serviceGetByUUIDRequest::serviceGetByUUIDRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void serviceGetByUUIDRequest::InitAsDefaultInstance() {
+}
+
+serviceGetByUUIDRequest::serviceGetByUUIDRequest(const serviceGetByUUIDRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void serviceGetByUUIDRequest::SharedCtor() {
+ _cached_size_ = 0;
+ name_ = const_cast< ::std::string*>(&_default_name_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+serviceGetByUUIDRequest::~serviceGetByUUIDRequest() {
+ SharedDtor();
+}
+
+void serviceGetByUUIDRequest::SharedDtor() {
+ if (name_ != &_default_name_) {
+ delete name_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void serviceGetByUUIDRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* serviceGetByUUIDRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return serviceGetByUUIDRequest_descriptor_;
+}
+
+const serviceGetByUUIDRequest& serviceGetByUUIDRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+serviceGetByUUIDRequest* serviceGetByUUIDRequest::default_instance_ = NULL;
+
+serviceGetByUUIDRequest* serviceGetByUUIDRequest::New() const {
+ return new serviceGetByUUIDRequest;
+}
+
+void serviceGetByUUIDRequest::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (name_ != &_default_name_) {
+ name_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool serviceGetByUUIDRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string name = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_name()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->name().data(), this->name().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void serviceGetByUUIDRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string name = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->name().data(), this->name().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->name(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* serviceGetByUUIDRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string name = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->name().data(), this->name().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->name(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int serviceGetByUUIDRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string name = 1;
+ if (has_name()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->name());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void serviceGetByUUIDRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const serviceGetByUUIDRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void serviceGetByUUIDRequest::MergeFrom(const serviceGetByUUIDRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_name(from.name());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void serviceGetByUUIDRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void serviceGetByUUIDRequest::CopyFrom(const serviceGetByUUIDRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool serviceGetByUUIDRequest::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void serviceGetByUUIDRequest::Swap(serviceGetByUUIDRequest* other) {
+ if (other != this) {
+ std::swap(name_, other->name_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata serviceGetByUUIDRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = serviceGetByUUIDRequest_descriptor_;
+ metadata.reflection = serviceGetByUUIDRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int serviceGetByTypeRequest::kTypeFieldNumber;
+#endif // !_MSC_VER
+
+serviceGetByTypeRequest::serviceGetByTypeRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void serviceGetByTypeRequest::InitAsDefaultInstance() {
+}
+
+serviceGetByTypeRequest::serviceGetByTypeRequest(const serviceGetByTypeRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void serviceGetByTypeRequest::SharedCtor() {
+ _cached_size_ = 0;
+ type_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+serviceGetByTypeRequest::~serviceGetByTypeRequest() {
+ SharedDtor();
+}
+
+void serviceGetByTypeRequest::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void serviceGetByTypeRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* serviceGetByTypeRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return serviceGetByTypeRequest_descriptor_;
+}
+
+const serviceGetByTypeRequest& serviceGetByTypeRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+serviceGetByTypeRequest* serviceGetByTypeRequest::default_instance_ = NULL;
+
+serviceGetByTypeRequest* serviceGetByTypeRequest::New() const {
+ return new serviceGetByTypeRequest;
+}
+
+void serviceGetByTypeRequest::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ type_ = 0;
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool serviceGetByTypeRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ int value;
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+ input, &value)));
+ if (xtreemfs::pbrpc::ServiceType_IsValid(value)) {
+ set_type(static_cast< xtreemfs::pbrpc::ServiceType >(value));
+ } else {
+ mutable_unknown_fields()->AddVarint(1, value);
+ }
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void serviceGetByTypeRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteEnum(
+ 1, this->type(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* serviceGetByTypeRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+ 1, this->type(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int serviceGetByTypeRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ if (has_type()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void serviceGetByTypeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const serviceGetByTypeRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void serviceGetByTypeRequest::MergeFrom(const serviceGetByTypeRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_type(from.type());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void serviceGetByTypeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void serviceGetByTypeRequest::CopyFrom(const serviceGetByTypeRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool serviceGetByTypeRequest::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void serviceGetByTypeRequest::Swap(serviceGetByTypeRequest* other) {
+ if (other != this) {
+ std::swap(type_, other->type_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata serviceGetByTypeRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = serviceGetByTypeRequest_descriptor_;
+ metadata.reflection = serviceGetByTypeRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int serviceRegisterRequest::kServiceFieldNumber;
+#endif // !_MSC_VER
+
+serviceRegisterRequest::serviceRegisterRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void serviceRegisterRequest::InitAsDefaultInstance() {
+ service_ = const_cast< ::xtreemfs::pbrpc::Service*>(&::xtreemfs::pbrpc::Service::default_instance());
+}
+
+serviceRegisterRequest::serviceRegisterRequest(const serviceRegisterRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void serviceRegisterRequest::SharedCtor() {
+ _cached_size_ = 0;
+ service_ = NULL;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+serviceRegisterRequest::~serviceRegisterRequest() {
+ SharedDtor();
+}
+
+void serviceRegisterRequest::SharedDtor() {
+ if (this != default_instance_) {
+ delete service_;
+ }
+}
+
+void serviceRegisterRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* serviceRegisterRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return serviceRegisterRequest_descriptor_;
+}
+
+const serviceRegisterRequest& serviceRegisterRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+serviceRegisterRequest* serviceRegisterRequest::default_instance_ = NULL;
+
+serviceRegisterRequest* serviceRegisterRequest::New() const {
+ return new serviceRegisterRequest;
+}
+
+void serviceRegisterRequest::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (service_ != NULL) service_->::xtreemfs::pbrpc::Service::Clear();
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool serviceRegisterRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required .xtreemfs.pbrpc.Service service = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+ input, mutable_service()));
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void serviceRegisterRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required .xtreemfs.pbrpc.Service service = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+ 1, this->service(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* serviceRegisterRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required .xtreemfs.pbrpc.Service service = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::
+ WriteMessageNoVirtualToArray(
+ 1, this->service(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int serviceRegisterRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required .xtreemfs.pbrpc.Service service = 1;
+ if (has_service()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+ this->service());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void serviceRegisterRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const serviceRegisterRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void serviceRegisterRequest::MergeFrom(const serviceRegisterRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ mutable_service()->::xtreemfs::pbrpc::Service::MergeFrom(from.service());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void serviceRegisterRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void serviceRegisterRequest::CopyFrom(const serviceRegisterRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool serviceRegisterRequest::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ if (has_service()) {
+ if (!this->service().IsInitialized()) return false;
+ }
+ return true;
+}
+
+void serviceRegisterRequest::Swap(serviceRegisterRequest* other) {
+ if (other != this) {
+ std::swap(service_, other->service_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata serviceRegisterRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = serviceRegisterRequest_descriptor_;
+ metadata.reflection = serviceRegisterRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int serviceRegisterResponse::kNewVersionFieldNumber;
+#endif // !_MSC_VER
+
+serviceRegisterResponse::serviceRegisterResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void serviceRegisterResponse::InitAsDefaultInstance() {
+}
+
+serviceRegisterResponse::serviceRegisterResponse(const serviceRegisterResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void serviceRegisterResponse::SharedCtor() {
+ _cached_size_ = 0;
+ new_version_ = GOOGLE_ULONGLONG(0);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+serviceRegisterResponse::~serviceRegisterResponse() {
+ SharedDtor();
+}
+
+void serviceRegisterResponse::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void serviceRegisterResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* serviceRegisterResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return serviceRegisterResponse_descriptor_;
+}
+
+const serviceRegisterResponse& serviceRegisterResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+serviceRegisterResponse* serviceRegisterResponse::default_instance_ = NULL;
+
+serviceRegisterResponse* serviceRegisterResponse::New() const {
+ return new serviceRegisterResponse;
+}
+
+void serviceRegisterResponse::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ new_version_ = GOOGLE_ULONGLONG(0);
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool serviceRegisterResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required fixed64 new_version = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+ input, &new_version_)));
+ _set_bit(0);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void serviceRegisterResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required fixed64 new_version = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* serviceRegisterResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required fixed64 new_version = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int serviceRegisterResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required fixed64 new_version = 1;
+ if (has_new_version()) {
+ total_size += 1 + 8;
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void serviceRegisterResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const serviceRegisterResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void serviceRegisterResponse::MergeFrom(const serviceRegisterResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_new_version(from.new_version());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void serviceRegisterResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void serviceRegisterResponse::CopyFrom(const serviceRegisterResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool serviceRegisterResponse::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void serviceRegisterResponse::Swap(serviceRegisterResponse* other) {
+ if (other != this) {
+ std::swap(new_version_, other->new_version_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata serviceRegisterResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = serviceRegisterResponse_descriptor_;
+ metadata.reflection = serviceRegisterResponse_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string configurationGetRequest::_default_uuid_;
+#ifndef _MSC_VER
+const int configurationGetRequest::kUuidFieldNumber;
+#endif // !_MSC_VER
+
+configurationGetRequest::configurationGetRequest()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void configurationGetRequest::InitAsDefaultInstance() {
+}
+
+configurationGetRequest::configurationGetRequest(const configurationGetRequest& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void configurationGetRequest::SharedCtor() {
+ _cached_size_ = 0;
+ uuid_ = const_cast< ::std::string*>(&_default_uuid_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+configurationGetRequest::~configurationGetRequest() {
+ SharedDtor();
+}
+
+void configurationGetRequest::SharedDtor() {
+ if (uuid_ != &_default_uuid_) {
+ delete uuid_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void configurationGetRequest::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* configurationGetRequest::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return configurationGetRequest_descriptor_;
+}
+
+const configurationGetRequest& configurationGetRequest::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+configurationGetRequest* configurationGetRequest::default_instance_ = NULL;
+
+configurationGetRequest* configurationGetRequest::New() const {
+ return new configurationGetRequest;
+}
+
+void configurationGetRequest::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (_has_bit(0)) {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool configurationGetRequest::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // required string uuid = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_uuid()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void configurationGetRequest::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 1, this->uuid(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* configurationGetRequest::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // required string uuid = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->uuid().data(), this->uuid().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 1, this->uuid(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int configurationGetRequest::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // required string uuid = 1;
+ if (has_uuid()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->uuid());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void configurationGetRequest::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const configurationGetRequest* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void configurationGetRequest::MergeFrom(const configurationGetRequest& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_uuid(from.uuid());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void configurationGetRequest::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void configurationGetRequest::CopyFrom(const configurationGetRequest& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool configurationGetRequest::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void configurationGetRequest::Swap(configurationGetRequest* other) {
+ if (other != this) {
+ std::swap(uuid_, other->uuid_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata configurationGetRequest::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = configurationGetRequest_descriptor_;
+ metadata.reflection = configurationGetRequest_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int configurationSetResponse::kNewVersionFieldNumber;
+#endif // !_MSC_VER
+
+configurationSetResponse::configurationSetResponse()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void configurationSetResponse::InitAsDefaultInstance() {
+}
+
+configurationSetResponse::configurationSetResponse(const configurationSetResponse& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void configurationSetResponse::SharedCtor() {
+ _cached_size_ = 0;
+ new_version_ = GOOGLE_ULONGLONG(0);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+configurationSetResponse::~configurationSetResponse() {
+ SharedDtor();
+}
+
+void configurationSetResponse::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void configurationSetResponse::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* configurationSetResponse::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return configurationSetResponse_descriptor_;
+}
+
+const configurationSetResponse& configurationSetResponse::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto(); return *default_instance_;
+}
+
+configurationSetResponse* configurationSetResponse::default_instance_ = NULL;
+
+configurationSetResponse* configurationSetResponse::New() const {
+ return new configurationSetResponse;
+}
+
+void configurationSetResponse::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ new_version_ = GOOGLE_ULONGLONG(0);
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool configurationSetResponse::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // optional fixed64 new_version = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+ input, &new_version_)));
+ _set_bit(0);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void configurationSetResponse::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // optional fixed64 new_version = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* configurationSetResponse::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // optional fixed64 new_version = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int configurationSetResponse::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // optional fixed64 new_version = 1;
+ if (has_new_version()) {
+ total_size += 1 + 8;
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void configurationSetResponse::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const configurationSetResponse* source =
+ ::google::protobuf::internal::dynamic_cast_if_available(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void configurationSetResponse::MergeFrom(const configurationSetResponse& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_new_version(from.new_version());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void configurationSetResponse::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void configurationSetResponse::CopyFrom(const configurationSetResponse& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool configurationSetResponse::IsInitialized() const {
+
+ return true;
+}
+
+void configurationSetResponse::Swap(configurationSetResponse* other) {
+ if (other != this) {
+ std::swap(new_version_, other->new_version_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata configurationSetResponse::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = configurationSetResponse_descriptor_;
+ metadata.reflection = configurationSetResponse_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+DIRService::~DIRService() {}
+
+const ::google::protobuf::ServiceDescriptor* DIRService::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return DIRService_descriptor_;
+}
+
+const ::google::protobuf::ServiceDescriptor* DIRService::GetDescriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return DIRService_descriptor_;
+}
+
+void DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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 DIRService::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(), DIRService_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;
+ default:
+ GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
+ break;
+ }
+}
+
+const ::google::protobuf::Message& DIRService::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();
+ default:
+ GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
+ return *reinterpret_cast< ::google::protobuf::Message*>(NULL);
+ }
+}
+
+const ::google::protobuf::Message& DIRService::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();
+ default:
+ GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
+ return *reinterpret_cast< ::google::protobuf::Message*>(NULL);
+ }
+}
+
+DIRService_Stub::DIRService_Stub(::google::protobuf::RpcChannel* channel)
+ : channel_(channel), owns_channel_(false) {}
+DIRService_Stub::DIRService_Stub(
+ ::google::protobuf::RpcChannel* channel,
+ ::google::protobuf::Service::ChannelOwnership ownership)
+ : channel_(channel),
+ owns_channel_(ownership == ::google::protobuf::Service::STUB_OWNS_CHANNEL) {}
+DIRService_Stub::~DIRService_Stub() {
+ if (owns_channel_) delete channel_;
+}
+
+void DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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 DIRService_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);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/cpp/generated/xtreemfs/DIR.pb.h b/cpp/generated/xtreemfs/DIR.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..efa1d828bb086bb183cde15a63f401a9449e3827
--- /dev/null
+++ b/cpp/generated/xtreemfs/DIR.pb.h
@@ -0,0 +1,3290 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: xtreemfs/DIR.proto
+
+#ifndef PROTOBUF_xtreemfs_2fDIR_2eproto__INCLUDED
+#define PROTOBUF_xtreemfs_2fDIR_2eproto__INCLUDED
+
+#include
+
+#include
+
+#if GOOGLE_PROTOBUF_VERSION < 2003000
+#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
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include
+#include
+#include
+#include
+#include
+#include "include/PBRPC.pb.h"
+#include "include/Common.pb.h"
+#include "xtreemfs/GlobalTypes.pb.h"
+// @@protoc_insertion_point(includes)
+
+namespace xtreemfs {
+namespace pbrpc {
+
+// Internal implementation detail -- do not call these.
+void protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
+void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto();
+void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto();
+
+class AddressMapping;
+class AddressMappingSet;
+class DirService;
+class ServiceDataMap;
+class Service;
+class ServiceSet;
+class Configuration;
+class addressMappingGetRequest;
+class addressMappingGetResponse;
+class addressMappingSetResponse;
+class globalTimeSGetResponse;
+class serviceDeregisterRequest;
+class serviceGetByNameRequest;
+class serviceGetByUUIDRequest;
+class serviceGetByTypeRequest;
+class serviceRegisterRequest;
+class serviceRegisterResponse;
+class configurationGetRequest;
+class configurationSetResponse;
+
+enum ServiceType {
+ SERVICE_TYPE_MIXED = 0,
+ SERVICE_TYPE_MRC = 1,
+ SERVICE_TYPE_OSD = 2,
+ SERVICE_TYPE_VOLUME = 3
+};
+bool ServiceType_IsValid(int value);
+const ServiceType ServiceType_MIN = SERVICE_TYPE_MIXED;
+const ServiceType ServiceType_MAX = SERVICE_TYPE_VOLUME;
+const int ServiceType_ARRAYSIZE = ServiceType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceType_descriptor();
+inline const ::std::string& ServiceType_Name(ServiceType value) {
+ return ::google::protobuf::internal::NameOfEnum(
+ ServiceType_descriptor(), value);
+}
+inline bool ServiceType_Parse(
+ const ::std::string& name, ServiceType* value) {
+ return ::google::protobuf::internal::ParseNamedEnum(
+ ServiceType_descriptor(), name, value);
+}
+enum ServiceStatus {
+ SERVICE_STATUS_AVAIL = 0,
+ SERVICE_STATUS_TO_BE_REMOVED = 1,
+ SERVICE_STATUS_REMOVED = 2
+};
+bool ServiceStatus_IsValid(int value);
+const ServiceStatus ServiceStatus_MIN = SERVICE_STATUS_AVAIL;
+const ServiceStatus ServiceStatus_MAX = SERVICE_STATUS_REMOVED;
+const int ServiceStatus_ARRAYSIZE = ServiceStatus_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor();
+inline const ::std::string& ServiceStatus_Name(ServiceStatus value) {
+ return ::google::protobuf::internal::NameOfEnum(
+ ServiceStatus_descriptor(), value);
+}
+inline bool ServiceStatus_Parse(
+ const ::std::string& name, ServiceStatus* value) {
+ return ::google::protobuf::internal::ParseNamedEnum(
+ ServiceStatus_descriptor(), name, value);
+}
+// ===================================================================
+
+class AddressMapping : public ::google::protobuf::Message {
+ public:
+ AddressMapping();
+ virtual ~AddressMapping();
+
+ AddressMapping(const AddressMapping& from);
+
+ inline AddressMapping& operator=(const AddressMapping& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const AddressMapping& default_instance();
+
+ void Swap(AddressMapping* other);
+
+ // implements Message ----------------------------------------------
+
+ AddressMapping* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const AddressMapping& from);
+ void MergeFrom(const AddressMapping& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string uuid = 1;
+ inline bool has_uuid() const;
+ inline void clear_uuid();
+ static const int kUuidFieldNumber = 1;
+ inline const ::std::string& uuid() const;
+ inline void set_uuid(const ::std::string& value);
+ inline void set_uuid(const char* value);
+ inline void set_uuid(const char* value, size_t size);
+ inline ::std::string* mutable_uuid();
+
+ // required fixed64 version = 2;
+ inline bool has_version() const;
+ inline void clear_version();
+ static const int kVersionFieldNumber = 2;
+ inline ::google::protobuf::uint64 version() const;
+ inline void set_version(::google::protobuf::uint64 value);
+
+ // required string protocol = 3;
+ inline bool has_protocol() const;
+ inline void clear_protocol();
+ static const int kProtocolFieldNumber = 3;
+ inline const ::std::string& protocol() const;
+ inline void set_protocol(const ::std::string& value);
+ inline void set_protocol(const char* value);
+ inline void set_protocol(const char* value, size_t size);
+ inline ::std::string* mutable_protocol();
+
+ // required string address = 4;
+ inline bool has_address() const;
+ inline void clear_address();
+ static const int kAddressFieldNumber = 4;
+ inline const ::std::string& address() const;
+ inline void set_address(const ::std::string& value);
+ inline void set_address(const char* value);
+ inline void set_address(const char* value, size_t size);
+ inline ::std::string* mutable_address();
+
+ // required fixed32 port = 5;
+ inline bool has_port() const;
+ inline void clear_port();
+ static const int kPortFieldNumber = 5;
+ inline ::google::protobuf::uint32 port() const;
+ inline void set_port(::google::protobuf::uint32 value);
+
+ // required string match_network = 6;
+ inline bool has_match_network() const;
+ inline void clear_match_network();
+ static const int kMatchNetworkFieldNumber = 6;
+ inline const ::std::string& match_network() const;
+ inline void set_match_network(const ::std::string& value);
+ inline void set_match_network(const char* value);
+ inline void set_match_network(const char* value, size_t size);
+ inline ::std::string* mutable_match_network();
+
+ // required fixed32 ttl_s = 7;
+ inline bool has_ttl_s() const;
+ inline void clear_ttl_s();
+ static const int kTtlSFieldNumber = 7;
+ inline ::google::protobuf::uint32 ttl_s() const;
+ inline void set_ttl_s(::google::protobuf::uint32 value);
+
+ // required string uri = 8;
+ inline bool has_uri() const;
+ inline void clear_uri();
+ static const int kUriFieldNumber = 8;
+ inline const ::std::string& uri() const;
+ inline void set_uri(const ::std::string& value);
+ inline void set_uri(const char* value);
+ inline void set_uri(const char* value, size_t size);
+ inline ::std::string* mutable_uri();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.AddressMapping)
+ private:
+ ::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 ttl_s_;
+ ::std::string* uri_;
+ static const ::std::string _default_uri_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class AddressMappingSet : public ::google::protobuf::Message {
+ public:
+ AddressMappingSet();
+ virtual ~AddressMappingSet();
+
+ AddressMappingSet(const AddressMappingSet& from);
+
+ inline AddressMappingSet& operator=(const AddressMappingSet& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const AddressMappingSet& default_instance();
+
+ void Swap(AddressMappingSet* other);
+
+ // implements Message ----------------------------------------------
+
+ AddressMappingSet* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const AddressMappingSet& from);
+ void MergeFrom(const AddressMappingSet& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
+ inline int mappings_size() const;
+ inline void clear_mappings();
+ static const int kMappingsFieldNumber = 1;
+ inline const ::xtreemfs::pbrpc::AddressMapping& mappings(int index) const;
+ inline ::xtreemfs::pbrpc::AddressMapping* mutable_mappings(int index);
+ inline ::xtreemfs::pbrpc::AddressMapping* add_mappings();
+ inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping >&
+ mappings() const;
+ inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping >*
+ mutable_mappings();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.AddressMappingSet)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping > mappings_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class DirService : public ::google::protobuf::Message {
+ public:
+ DirService();
+ virtual ~DirService();
+
+ DirService(const DirService& from);
+
+ inline DirService& operator=(const DirService& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const DirService& default_instance();
+
+ void Swap(DirService* other);
+
+ // implements Message ----------------------------------------------
+
+ DirService* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const DirService& from);
+ void MergeFrom(const DirService& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string address = 1;
+ inline bool has_address() const;
+ inline void clear_address();
+ static const int kAddressFieldNumber = 1;
+ inline const ::std::string& address() const;
+ inline void set_address(const ::std::string& value);
+ inline void set_address(const char* value);
+ inline void set_address(const char* value, size_t size);
+ inline ::std::string* mutable_address();
+
+ // required fixed32 port = 2;
+ inline bool has_port() const;
+ inline void clear_port();
+ static const int kPortFieldNumber = 2;
+ inline ::google::protobuf::uint32 port() const;
+ inline void set_port(::google::protobuf::uint32 value);
+
+ // required string protocol = 3;
+ inline bool has_protocol() const;
+ inline void clear_protocol();
+ static const int kProtocolFieldNumber = 3;
+ inline const ::std::string& protocol() const;
+ inline void set_protocol(const ::std::string& value);
+ inline void set_protocol(const char* value);
+ inline void set_protocol(const char* value, size_t size);
+ inline ::std::string* mutable_protocol();
+
+ // 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:
+ ::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 interface_version_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class ServiceDataMap : public ::google::protobuf::Message {
+ public:
+ ServiceDataMap();
+ virtual ~ServiceDataMap();
+
+ ServiceDataMap(const ServiceDataMap& from);
+
+ inline ServiceDataMap& operator=(const ServiceDataMap& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const ServiceDataMap& default_instance();
+
+ void Swap(ServiceDataMap* other);
+
+ // implements Message ----------------------------------------------
+
+ ServiceDataMap* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const ServiceDataMap& from);
+ void MergeFrom(const ServiceDataMap& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
+ inline int data_size() const;
+ inline void clear_data();
+ static const int kDataFieldNumber = 1;
+ inline const ::xtreemfs::pbrpc::KeyValuePair& data(int index) const;
+ inline ::xtreemfs::pbrpc::KeyValuePair* mutable_data(int index);
+ inline ::xtreemfs::pbrpc::KeyValuePair* add_data();
+ inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >&
+ data() const;
+ inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >*
+ mutable_data();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ServiceDataMap)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair > data_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class Service : public ::google::protobuf::Message {
+ public:
+ Service();
+ virtual ~Service();
+
+ Service(const Service& from);
+
+ inline Service& operator=(const Service& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const Service& default_instance();
+
+ void Swap(Service* other);
+
+ // implements Message ----------------------------------------------
+
+ Service* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const Service& from);
+ void MergeFrom(const Service& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ inline bool has_type() const;
+ inline void clear_type();
+ static const int kTypeFieldNumber = 1;
+ inline xtreemfs::pbrpc::ServiceType type() const;
+ inline void set_type(xtreemfs::pbrpc::ServiceType value);
+
+ // required string uuid = 2;
+ inline bool has_uuid() const;
+ inline void clear_uuid();
+ static const int kUuidFieldNumber = 2;
+ inline const ::std::string& uuid() const;
+ inline void set_uuid(const ::std::string& value);
+ inline void set_uuid(const char* value);
+ inline void set_uuid(const char* value, size_t size);
+ inline ::std::string* mutable_uuid();
+
+ // required fixed64 version = 3;
+ inline bool has_version() const;
+ inline void clear_version();
+ static const int kVersionFieldNumber = 3;
+ inline ::google::protobuf::uint64 version() const;
+ inline void set_version(::google::protobuf::uint64 value);
+
+ // required string name = 4;
+ inline bool has_name() const;
+ inline void clear_name();
+ static const int kNameFieldNumber = 4;
+ inline const ::std::string& name() const;
+ inline void set_name(const ::std::string& value);
+ inline void set_name(const char* value);
+ inline void set_name(const char* value, size_t size);
+ inline ::std::string* mutable_name();
+
+ // 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();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Service)
+ private:
+ ::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_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class ServiceSet : public ::google::protobuf::Message {
+ public:
+ ServiceSet();
+ virtual ~ServiceSet();
+
+ ServiceSet(const ServiceSet& from);
+
+ inline ServiceSet& operator=(const ServiceSet& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const ServiceSet& default_instance();
+
+ void Swap(ServiceSet* other);
+
+ // implements Message ----------------------------------------------
+
+ ServiceSet* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const ServiceSet& from);
+ void MergeFrom(const ServiceSet& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // repeated .xtreemfs.pbrpc.Service services = 1;
+ inline int services_size() const;
+ inline void clear_services();
+ static const int kServicesFieldNumber = 1;
+ inline const ::xtreemfs::pbrpc::Service& services(int index) const;
+ inline ::xtreemfs::pbrpc::Service* mutable_services(int index);
+ inline ::xtreemfs::pbrpc::Service* add_services();
+ inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service >&
+ services() const;
+ inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service >*
+ mutable_services();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.ServiceSet)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service > services_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class Configuration : public ::google::protobuf::Message {
+ public:
+ Configuration();
+ virtual ~Configuration();
+
+ Configuration(const Configuration& from);
+
+ inline Configuration& operator=(const Configuration& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const Configuration& default_instance();
+
+ void Swap(Configuration* other);
+
+ // implements Message ----------------------------------------------
+
+ Configuration* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const Configuration& from);
+ void MergeFrom(const Configuration& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string uuid = 1;
+ inline bool has_uuid() const;
+ inline void clear_uuid();
+ static const int kUuidFieldNumber = 1;
+ inline const ::std::string& uuid() const;
+ inline void set_uuid(const ::std::string& value);
+ inline void set_uuid(const char* value);
+ inline void set_uuid(const char* value, size_t size);
+ inline ::std::string* mutable_uuid();
+
+ // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
+ inline int parameter_size() const;
+ inline void clear_parameter();
+ static const int kParameterFieldNumber = 2;
+ inline const ::xtreemfs::pbrpc::KeyValuePair& parameter(int index) const;
+ inline ::xtreemfs::pbrpc::KeyValuePair* mutable_parameter(int index);
+ inline ::xtreemfs::pbrpc::KeyValuePair* add_parameter();
+ inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >&
+ parameter() const;
+ inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >*
+ mutable_parameter();
+
+ // required fixed64 version = 3;
+ inline bool has_version() const;
+ inline void clear_version();
+ static const int kVersionFieldNumber = 3;
+ inline ::google::protobuf::uint64 version() const;
+ inline void set_version(::google::protobuf::uint64 value);
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.Configuration)
+ private:
+ ::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_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class addressMappingGetRequest : public ::google::protobuf::Message {
+ public:
+ addressMappingGetRequest();
+ virtual ~addressMappingGetRequest();
+
+ addressMappingGetRequest(const addressMappingGetRequest& from);
+
+ inline addressMappingGetRequest& operator=(const addressMappingGetRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const addressMappingGetRequest& default_instance();
+
+ void Swap(addressMappingGetRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ addressMappingGetRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const addressMappingGetRequest& from);
+ void MergeFrom(const addressMappingGetRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string uuid = 1;
+ inline bool has_uuid() const;
+ inline void clear_uuid();
+ static const int kUuidFieldNumber = 1;
+ inline const ::std::string& uuid() const;
+ inline void set_uuid(const ::std::string& value);
+ inline void set_uuid(const char* value);
+ inline void set_uuid(const char* value, size_t size);
+ inline ::std::string* mutable_uuid();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.addressMappingGetRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* uuid_;
+ static const ::std::string _default_uuid_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class addressMappingGetResponse : public ::google::protobuf::Message {
+ public:
+ addressMappingGetResponse();
+ virtual ~addressMappingGetResponse();
+
+ addressMappingGetResponse(const addressMappingGetResponse& from);
+
+ inline addressMappingGetResponse& operator=(const addressMappingGetResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const addressMappingGetResponse& default_instance();
+
+ void Swap(addressMappingGetResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ addressMappingGetResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const addressMappingGetResponse& from);
+ void MergeFrom(const addressMappingGetResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
+ inline bool has_result() const;
+ inline void clear_result();
+ static const int kResultFieldNumber = 1;
+ inline const ::xtreemfs::pbrpc::AddressMappingSet& result() const;
+ inline ::xtreemfs::pbrpc::AddressMappingSet* mutable_result();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.addressMappingGetResponse)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::xtreemfs::pbrpc::AddressMappingSet* result_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class addressMappingSetResponse : public ::google::protobuf::Message {
+ public:
+ addressMappingSetResponse();
+ virtual ~addressMappingSetResponse();
+
+ addressMappingSetResponse(const addressMappingSetResponse& from);
+
+ inline addressMappingSetResponse& operator=(const addressMappingSetResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const addressMappingSetResponse& default_instance();
+
+ void Swap(addressMappingSetResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ addressMappingSetResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const addressMappingSetResponse& from);
+ void MergeFrom(const addressMappingSetResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // optional fixed64 new_version = 1;
+ inline bool has_new_version() const;
+ inline void clear_new_version();
+ static const int kNewVersionFieldNumber = 1;
+ inline ::google::protobuf::uint64 new_version() const;
+ inline void set_new_version(::google::protobuf::uint64 value);
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.addressMappingSetResponse)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::google::protobuf::uint64 new_version_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class globalTimeSGetResponse : public ::google::protobuf::Message {
+ public:
+ globalTimeSGetResponse();
+ virtual ~globalTimeSGetResponse();
+
+ globalTimeSGetResponse(const globalTimeSGetResponse& from);
+
+ inline globalTimeSGetResponse& operator=(const globalTimeSGetResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const globalTimeSGetResponse& default_instance();
+
+ void Swap(globalTimeSGetResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ globalTimeSGetResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const globalTimeSGetResponse& from);
+ void MergeFrom(const globalTimeSGetResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required fixed64 time_in_seconds = 1;
+ inline bool has_time_in_seconds() const;
+ inline void clear_time_in_seconds();
+ static const int kTimeInSecondsFieldNumber = 1;
+ inline ::google::protobuf::uint64 time_in_seconds() const;
+ inline void set_time_in_seconds(::google::protobuf::uint64 value);
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.globalTimeSGetResponse)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::google::protobuf::uint64 time_in_seconds_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class serviceDeregisterRequest : public ::google::protobuf::Message {
+ public:
+ serviceDeregisterRequest();
+ virtual ~serviceDeregisterRequest();
+
+ serviceDeregisterRequest(const serviceDeregisterRequest& from);
+
+ inline serviceDeregisterRequest& operator=(const serviceDeregisterRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const serviceDeregisterRequest& default_instance();
+
+ void Swap(serviceDeregisterRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ serviceDeregisterRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const serviceDeregisterRequest& from);
+ void MergeFrom(const serviceDeregisterRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string uuid = 1;
+ inline bool has_uuid() const;
+ inline void clear_uuid();
+ static const int kUuidFieldNumber = 1;
+ inline const ::std::string& uuid() const;
+ inline void set_uuid(const ::std::string& value);
+ inline void set_uuid(const char* value);
+ inline void set_uuid(const char* value, size_t size);
+ inline ::std::string* mutable_uuid();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceDeregisterRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* uuid_;
+ static const ::std::string _default_uuid_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class serviceGetByNameRequest : public ::google::protobuf::Message {
+ public:
+ serviceGetByNameRequest();
+ virtual ~serviceGetByNameRequest();
+
+ serviceGetByNameRequest(const serviceGetByNameRequest& from);
+
+ inline serviceGetByNameRequest& operator=(const serviceGetByNameRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const serviceGetByNameRequest& default_instance();
+
+ void Swap(serviceGetByNameRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ serviceGetByNameRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const serviceGetByNameRequest& from);
+ void MergeFrom(const serviceGetByNameRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string name = 1;
+ inline bool has_name() const;
+ inline void clear_name();
+ static const int kNameFieldNumber = 1;
+ inline const ::std::string& name() const;
+ inline void set_name(const ::std::string& value);
+ inline void set_name(const char* value);
+ inline void set_name(const char* value, size_t size);
+ inline ::std::string* mutable_name();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceGetByNameRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* name_;
+ static const ::std::string _default_name_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class serviceGetByUUIDRequest : public ::google::protobuf::Message {
+ public:
+ serviceGetByUUIDRequest();
+ virtual ~serviceGetByUUIDRequest();
+
+ serviceGetByUUIDRequest(const serviceGetByUUIDRequest& from);
+
+ inline serviceGetByUUIDRequest& operator=(const serviceGetByUUIDRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const serviceGetByUUIDRequest& default_instance();
+
+ void Swap(serviceGetByUUIDRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ serviceGetByUUIDRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const serviceGetByUUIDRequest& from);
+ void MergeFrom(const serviceGetByUUIDRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string name = 1;
+ inline bool has_name() const;
+ inline void clear_name();
+ static const int kNameFieldNumber = 1;
+ inline const ::std::string& name() const;
+ inline void set_name(const ::std::string& value);
+ inline void set_name(const char* value);
+ inline void set_name(const char* value, size_t size);
+ inline ::std::string* mutable_name();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceGetByUUIDRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* name_;
+ static const ::std::string _default_name_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class serviceGetByTypeRequest : public ::google::protobuf::Message {
+ public:
+ serviceGetByTypeRequest();
+ virtual ~serviceGetByTypeRequest();
+
+ serviceGetByTypeRequest(const serviceGetByTypeRequest& from);
+
+ inline serviceGetByTypeRequest& operator=(const serviceGetByTypeRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const serviceGetByTypeRequest& default_instance();
+
+ void Swap(serviceGetByTypeRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ serviceGetByTypeRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const serviceGetByTypeRequest& from);
+ void MergeFrom(const serviceGetByTypeRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required .xtreemfs.pbrpc.ServiceType type = 1;
+ inline bool has_type() const;
+ inline void clear_type();
+ static const int kTypeFieldNumber = 1;
+ inline xtreemfs::pbrpc::ServiceType type() const;
+ inline void set_type(xtreemfs::pbrpc::ServiceType value);
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceGetByTypeRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ int type_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class serviceRegisterRequest : public ::google::protobuf::Message {
+ public:
+ serviceRegisterRequest();
+ virtual ~serviceRegisterRequest();
+
+ serviceRegisterRequest(const serviceRegisterRequest& from);
+
+ inline serviceRegisterRequest& operator=(const serviceRegisterRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const serviceRegisterRequest& default_instance();
+
+ void Swap(serviceRegisterRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ serviceRegisterRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const serviceRegisterRequest& from);
+ void MergeFrom(const serviceRegisterRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required .xtreemfs.pbrpc.Service service = 1;
+ inline bool has_service() const;
+ inline void clear_service();
+ static const int kServiceFieldNumber = 1;
+ inline const ::xtreemfs::pbrpc::Service& service() const;
+ inline ::xtreemfs::pbrpc::Service* mutable_service();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceRegisterRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::xtreemfs::pbrpc::Service* service_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class serviceRegisterResponse : public ::google::protobuf::Message {
+ public:
+ serviceRegisterResponse();
+ virtual ~serviceRegisterResponse();
+
+ serviceRegisterResponse(const serviceRegisterResponse& from);
+
+ inline serviceRegisterResponse& operator=(const serviceRegisterResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const serviceRegisterResponse& default_instance();
+
+ void Swap(serviceRegisterResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ serviceRegisterResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const serviceRegisterResponse& from);
+ void MergeFrom(const serviceRegisterResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required fixed64 new_version = 1;
+ inline bool has_new_version() const;
+ inline void clear_new_version();
+ static const int kNewVersionFieldNumber = 1;
+ inline ::google::protobuf::uint64 new_version() const;
+ inline void set_new_version(::google::protobuf::uint64 value);
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.serviceRegisterResponse)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::google::protobuf::uint64 new_version_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class configurationGetRequest : public ::google::protobuf::Message {
+ public:
+ configurationGetRequest();
+ virtual ~configurationGetRequest();
+
+ configurationGetRequest(const configurationGetRequest& from);
+
+ inline configurationGetRequest& operator=(const configurationGetRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const configurationGetRequest& default_instance();
+
+ void Swap(configurationGetRequest* other);
+
+ // implements Message ----------------------------------------------
+
+ configurationGetRequest* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const configurationGetRequest& from);
+ void MergeFrom(const configurationGetRequest& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // required string uuid = 1;
+ inline bool has_uuid() const;
+ inline void clear_uuid();
+ static const int kUuidFieldNumber = 1;
+ inline const ::std::string& uuid() const;
+ inline void set_uuid(const ::std::string& value);
+ inline void set_uuid(const char* value);
+ inline void set_uuid(const char* value, size_t size);
+ inline ::std::string* mutable_uuid();
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.configurationGetRequest)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::std::string* uuid_;
+ static const ::std::string _default_uuid_;
+ 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_;
+};
+// -------------------------------------------------------------------
+
+class configurationSetResponse : public ::google::protobuf::Message {
+ public:
+ configurationSetResponse();
+ virtual ~configurationSetResponse();
+
+ configurationSetResponse(const configurationSetResponse& from);
+
+ inline configurationSetResponse& operator=(const configurationSetResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+ return _unknown_fields_;
+ }
+
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+ return &_unknown_fields_;
+ }
+
+ static const ::google::protobuf::Descriptor* descriptor();
+ static const configurationSetResponse& default_instance();
+
+ void Swap(configurationSetResponse* other);
+
+ // implements Message ----------------------------------------------
+
+ configurationSetResponse* New() const;
+ void CopyFrom(const ::google::protobuf::Message& from);
+ void MergeFrom(const ::google::protobuf::Message& from);
+ void CopyFrom(const configurationSetResponse& from);
+ void MergeFrom(const configurationSetResponse& from);
+ void Clear();
+ bool IsInitialized() const;
+
+ int ByteSize() const;
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input);
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const;
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+ int GetCachedSize() const { return _cached_size_; }
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // optional fixed64 new_version = 1;
+ inline bool has_new_version() const;
+ inline void clear_new_version();
+ static const int kNewVersionFieldNumber = 1;
+ inline ::google::protobuf::uint64 new_version() const;
+ inline void set_new_version(::google::protobuf::uint64 value);
+
+ // @@protoc_insertion_point(class_scope:xtreemfs.pbrpc.configurationSetResponse)
+ private:
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
+ mutable int _cached_size_;
+
+ ::google::protobuf::uint64 new_version_;
+ 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 DIRService_Stub;
+
+class DIRService : public ::google::protobuf::Service {
+ protected:
+ // This class should be treated as an abstract interface.
+ inline DIRService() {};
+ public:
+ virtual ~DIRService();
+
+ typedef DIRService_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);
+
+ // 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(DIRService);
+};
+
+class DIRService_Stub : public DIRService {
+ public:
+ DIRService_Stub(::google::protobuf::RpcChannel* channel);
+ DIRService_Stub(::google::protobuf::RpcChannel* channel,
+ ::google::protobuf::Service::ChannelOwnership ownership);
+ ~DIRService_Stub();
+
+ inline ::google::protobuf::RpcChannel* channel() { return channel_; }
+
+ // implements DIRService ------------------------------------------
+
+ 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);
+ private:
+ ::google::protobuf::RpcChannel* channel_;
+ bool owns_channel_;
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DIRService_Stub);
+};
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// AddressMapping
+
+// required string uuid = 1;
+inline bool AddressMapping::has_uuid() const {
+ return _has_bit(0);
+}
+inline void AddressMapping::clear_uuid() {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(value);
+}
+inline void AddressMapping::set_uuid(const char* value) {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ 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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* AddressMapping::mutable_uuid() {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ uuid_ = new ::std::string;
+ }
+ return uuid_;
+}
+
+// required fixed64 version = 2;
+inline bool AddressMapping::has_version() const {
+ return _has_bit(1);
+}
+inline void AddressMapping::clear_version() {
+ version_ = GOOGLE_ULONGLONG(0);
+ _clear_bit(1);
+}
+inline ::google::protobuf::uint64 AddressMapping::version() const {
+ return version_;
+}
+inline void AddressMapping::set_version(::google::protobuf::uint64 value) {
+ _set_bit(1);
+ version_ = value;
+}
+
+// required string protocol = 3;
+inline bool AddressMapping::has_protocol() const {
+ return _has_bit(2);
+}
+inline void AddressMapping::clear_protocol() {
+ if (protocol_ != &_default_protocol_) {
+ protocol_->clear();
+ }
+ _clear_bit(2);
+}
+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_) {
+ protocol_ = new ::std::string;
+ }
+ protocol_->assign(value);
+}
+inline void AddressMapping::set_protocol(const char* value) {
+ _set_bit(2);
+ if (protocol_ == &_default_protocol_) {
+ 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_) {
+ protocol_ = new ::std::string;
+ }
+ protocol_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* AddressMapping::mutable_protocol() {
+ _set_bit(2);
+ if (protocol_ == &_default_protocol_) {
+ protocol_ = new ::std::string;
+ }
+ return protocol_;
+}
+
+// required string address = 4;
+inline bool AddressMapping::has_address() const {
+ return _has_bit(3);
+}
+inline void AddressMapping::clear_address() {
+ if (address_ != &_default_address_) {
+ address_->clear();
+ }
+ _clear_bit(3);
+}
+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_) {
+ address_ = new ::std::string;
+ }
+ address_->assign(value);
+}
+inline void AddressMapping::set_address(const char* value) {
+ _set_bit(3);
+ if (address_ == &_default_address_) {
+ 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_) {
+ address_ = new ::std::string;
+ }
+ address_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* AddressMapping::mutable_address() {
+ _set_bit(3);
+ if (address_ == &_default_address_) {
+ address_ = new ::std::string;
+ }
+ return address_;
+}
+
+// required fixed32 port = 5;
+inline bool AddressMapping::has_port() const {
+ return _has_bit(4);
+}
+inline void AddressMapping::clear_port() {
+ port_ = 0u;
+ _clear_bit(4);
+}
+inline ::google::protobuf::uint32 AddressMapping::port() const {
+ return port_;
+}
+inline void AddressMapping::set_port(::google::protobuf::uint32 value) {
+ _set_bit(4);
+ port_ = value;
+}
+
+// required string match_network = 6;
+inline bool AddressMapping::has_match_network() const {
+ return _has_bit(5);
+}
+inline void AddressMapping::clear_match_network() {
+ if (match_network_ != &_default_match_network_) {
+ match_network_->clear();
+ }
+ _clear_bit(5);
+}
+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_) {
+ 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_) {
+ 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_) {
+ 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_) {
+ match_network_ = new ::std::string;
+ }
+ return match_network_;
+}
+
+// required fixed32 ttl_s = 7;
+inline bool AddressMapping::has_ttl_s() const {
+ return _has_bit(6);
+}
+inline void AddressMapping::clear_ttl_s() {
+ ttl_s_ = 0u;
+ _clear_bit(6);
+}
+inline ::google::protobuf::uint32 AddressMapping::ttl_s() const {
+ return ttl_s_;
+}
+inline void AddressMapping::set_ttl_s(::google::protobuf::uint32 value) {
+ _set_bit(6);
+ ttl_s_ = value;
+}
+
+// required string uri = 8;
+inline bool AddressMapping::has_uri() const {
+ return _has_bit(7);
+}
+inline void AddressMapping::clear_uri() {
+ if (uri_ != &_default_uri_) {
+ uri_->clear();
+ }
+ _clear_bit(7);
+}
+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_) {
+ uri_ = new ::std::string;
+ }
+ uri_->assign(value);
+}
+inline void AddressMapping::set_uri(const char* value) {
+ _set_bit(7);
+ if (uri_ == &_default_uri_) {
+ 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_) {
+ uri_ = new ::std::string;
+ }
+ uri_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* AddressMapping::mutable_uri() {
+ _set_bit(7);
+ if (uri_ == &_default_uri_) {
+ uri_ = new ::std::string;
+ }
+ return uri_;
+}
+
+// -------------------------------------------------------------------
+
+// AddressMappingSet
+
+// repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
+inline int AddressMappingSet::mappings_size() const {
+ return mappings_.size();
+}
+inline void AddressMappingSet::clear_mappings() {
+ mappings_.Clear();
+}
+inline const ::xtreemfs::pbrpc::AddressMapping& AddressMappingSet::mappings(int index) const {
+ return mappings_.Get(index);
+}
+inline ::xtreemfs::pbrpc::AddressMapping* AddressMappingSet::mutable_mappings(int index) {
+ return mappings_.Mutable(index);
+}
+inline ::xtreemfs::pbrpc::AddressMapping* AddressMappingSet::add_mappings() {
+ return mappings_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping >&
+AddressMappingSet::mappings() const {
+ return mappings_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::AddressMapping >*
+AddressMappingSet::mutable_mappings() {
+ return &mappings_;
+}
+
+// -------------------------------------------------------------------
+
+// DirService
+
+// required string address = 1;
+inline bool DirService::has_address() const {
+ return _has_bit(0);
+}
+inline void DirService::clear_address() {
+ if (address_ != &_default_address_) {
+ address_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ address_ = new ::std::string;
+ }
+ address_->assign(value);
+}
+inline void DirService::set_address(const char* value) {
+ _set_bit(0);
+ if (address_ == &_default_address_) {
+ 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_) {
+ address_ = new ::std::string;
+ }
+ address_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* DirService::mutable_address() {
+ _set_bit(0);
+ if (address_ == &_default_address_) {
+ address_ = new ::std::string;
+ }
+ return address_;
+}
+
+// required fixed32 port = 2;
+inline bool DirService::has_port() const {
+ return _has_bit(1);
+}
+inline void DirService::clear_port() {
+ port_ = 0u;
+ _clear_bit(1);
+}
+inline ::google::protobuf::uint32 DirService::port() const {
+ return port_;
+}
+inline void DirService::set_port(::google::protobuf::uint32 value) {
+ _set_bit(1);
+ port_ = value;
+}
+
+// required string protocol = 3;
+inline bool DirService::has_protocol() const {
+ return _has_bit(2);
+}
+inline void DirService::clear_protocol() {
+ if (protocol_ != &_default_protocol_) {
+ protocol_->clear();
+ }
+ _clear_bit(2);
+}
+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_) {
+ protocol_ = new ::std::string;
+ }
+ protocol_->assign(value);
+}
+inline void DirService::set_protocol(const char* value) {
+ _set_bit(2);
+ if (protocol_ == &_default_protocol_) {
+ 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_) {
+ protocol_ = new ::std::string;
+ }
+ protocol_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* DirService::mutable_protocol() {
+ _set_bit(2);
+ if (protocol_ == &_default_protocol_) {
+ protocol_ = new ::std::string;
+ }
+ return protocol_;
+}
+
+// required fixed32 interface_version = 4;
+inline bool DirService::has_interface_version() const {
+ return _has_bit(3);
+}
+inline void DirService::clear_interface_version() {
+ interface_version_ = 0u;
+ _clear_bit(3);
+}
+inline ::google::protobuf::uint32 DirService::interface_version() const {
+ return interface_version_;
+}
+inline void DirService::set_interface_version(::google::protobuf::uint32 value) {
+ _set_bit(3);
+ interface_version_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// ServiceDataMap
+
+// repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
+inline int ServiceDataMap::data_size() const {
+ return data_.size();
+}
+inline void ServiceDataMap::clear_data() {
+ data_.Clear();
+}
+inline const ::xtreemfs::pbrpc::KeyValuePair& ServiceDataMap::data(int index) const {
+ return data_.Get(index);
+}
+inline ::xtreemfs::pbrpc::KeyValuePair* ServiceDataMap::mutable_data(int index) {
+ return data_.Mutable(index);
+}
+inline ::xtreemfs::pbrpc::KeyValuePair* ServiceDataMap::add_data() {
+ return data_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >&
+ServiceDataMap::data() const {
+ return data_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >*
+ServiceDataMap::mutable_data() {
+ return &data_;
+}
+
+// -------------------------------------------------------------------
+
+// Service
+
+// required .xtreemfs.pbrpc.ServiceType type = 1;
+inline bool Service::has_type() const {
+ return _has_bit(0);
+}
+inline void Service::clear_type() {
+ type_ = 0;
+ _clear_bit(0);
+}
+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);
+ type_ = value;
+}
+
+// required string uuid = 2;
+inline bool Service::has_uuid() const {
+ return _has_bit(1);
+}
+inline void Service::clear_uuid() {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ _clear_bit(1);
+}
+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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(value);
+}
+inline void Service::set_uuid(const char* value) {
+ _set_bit(1);
+ if (uuid_ == &_default_uuid_) {
+ 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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* Service::mutable_uuid() {
+ _set_bit(1);
+ if (uuid_ == &_default_uuid_) {
+ uuid_ = new ::std::string;
+ }
+ return uuid_;
+}
+
+// required fixed64 version = 3;
+inline bool Service::has_version() const {
+ return _has_bit(2);
+}
+inline void Service::clear_version() {
+ version_ = GOOGLE_ULONGLONG(0);
+ _clear_bit(2);
+}
+inline ::google::protobuf::uint64 Service::version() const {
+ return version_;
+}
+inline void Service::set_version(::google::protobuf::uint64 value) {
+ _set_bit(2);
+ version_ = value;
+}
+
+// required string name = 4;
+inline bool Service::has_name() const {
+ return _has_bit(3);
+}
+inline void Service::clear_name() {
+ if (name_ != &_default_name_) {
+ name_->clear();
+ }
+ _clear_bit(3);
+}
+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_) {
+ name_ = new ::std::string;
+ }
+ name_->assign(value);
+}
+inline void Service::set_name(const char* value) {
+ _set_bit(3);
+ if (name_ == &_default_name_) {
+ 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_) {
+ name_ = new ::std::string;
+ }
+ name_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* Service::mutable_name() {
+ _set_bit(3);
+ if (name_ == &_default_name_) {
+ name_ = new ::std::string;
+ }
+ return name_;
+}
+
+// required fixed64 last_updated_s = 5;
+inline bool Service::has_last_updated_s() const {
+ return _has_bit(4);
+}
+inline void Service::clear_last_updated_s() {
+ last_updated_s_ = GOOGLE_ULONGLONG(0);
+ _clear_bit(4);
+}
+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);
+ last_updated_s_ = value;
+}
+
+// required .xtreemfs.pbrpc.ServiceDataMap data = 6;
+inline bool Service::has_data() const {
+ return _has_bit(5);
+}
+inline void Service::clear_data() {
+ if (data_ != NULL) data_->::xtreemfs::pbrpc::ServiceDataMap::Clear();
+ _clear_bit(5);
+}
+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);
+ if (data_ == NULL) data_ = new ::xtreemfs::pbrpc::ServiceDataMap;
+ return data_;
+}
+
+// -------------------------------------------------------------------
+
+// ServiceSet
+
+// repeated .xtreemfs.pbrpc.Service services = 1;
+inline int ServiceSet::services_size() const {
+ return services_.size();
+}
+inline void ServiceSet::clear_services() {
+ services_.Clear();
+}
+inline const ::xtreemfs::pbrpc::Service& ServiceSet::services(int index) const {
+ return services_.Get(index);
+}
+inline ::xtreemfs::pbrpc::Service* ServiceSet::mutable_services(int index) {
+ return services_.Mutable(index);
+}
+inline ::xtreemfs::pbrpc::Service* ServiceSet::add_services() {
+ return services_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service >&
+ServiceSet::services() const {
+ return services_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::Service >*
+ServiceSet::mutable_services() {
+ return &services_;
+}
+
+// -------------------------------------------------------------------
+
+// Configuration
+
+// required string uuid = 1;
+inline bool Configuration::has_uuid() const {
+ return _has_bit(0);
+}
+inline void Configuration::clear_uuid() {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(value);
+}
+inline void Configuration::set_uuid(const char* value) {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ 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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* Configuration::mutable_uuid() {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ uuid_ = new ::std::string;
+ }
+ return uuid_;
+}
+
+// repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
+inline int Configuration::parameter_size() const {
+ return parameter_.size();
+}
+inline void Configuration::clear_parameter() {
+ parameter_.Clear();
+}
+inline const ::xtreemfs::pbrpc::KeyValuePair& Configuration::parameter(int index) const {
+ return parameter_.Get(index);
+}
+inline ::xtreemfs::pbrpc::KeyValuePair* Configuration::mutable_parameter(int index) {
+ return parameter_.Mutable(index);
+}
+inline ::xtreemfs::pbrpc::KeyValuePair* Configuration::add_parameter() {
+ return parameter_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >&
+Configuration::parameter() const {
+ return parameter_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::xtreemfs::pbrpc::KeyValuePair >*
+Configuration::mutable_parameter() {
+ return ¶meter_;
+}
+
+// required fixed64 version = 3;
+inline bool Configuration::has_version() const {
+ return _has_bit(2);
+}
+inline void Configuration::clear_version() {
+ version_ = GOOGLE_ULONGLONG(0);
+ _clear_bit(2);
+}
+inline ::google::protobuf::uint64 Configuration::version() const {
+ return version_;
+}
+inline void Configuration::set_version(::google::protobuf::uint64 value) {
+ _set_bit(2);
+ version_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// addressMappingGetRequest
+
+// required string uuid = 1;
+inline bool addressMappingGetRequest::has_uuid() const {
+ return _has_bit(0);
+}
+inline void addressMappingGetRequest::clear_uuid() {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(value);
+}
+inline void addressMappingGetRequest::set_uuid(const char* value) {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ 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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* addressMappingGetRequest::mutable_uuid() {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ uuid_ = new ::std::string;
+ }
+ return uuid_;
+}
+
+// -------------------------------------------------------------------
+
+// addressMappingGetResponse
+
+// optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
+inline bool addressMappingGetResponse::has_result() const {
+ return _has_bit(0);
+}
+inline void addressMappingGetResponse::clear_result() {
+ if (result_ != NULL) result_->::xtreemfs::pbrpc::AddressMappingSet::Clear();
+ _clear_bit(0);
+}
+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);
+ if (result_ == NULL) result_ = new ::xtreemfs::pbrpc::AddressMappingSet;
+ return result_;
+}
+
+// -------------------------------------------------------------------
+
+// addressMappingSetResponse
+
+// optional fixed64 new_version = 1;
+inline bool addressMappingSetResponse::has_new_version() const {
+ return _has_bit(0);
+}
+inline void addressMappingSetResponse::clear_new_version() {
+ new_version_ = GOOGLE_ULONGLONG(0);
+ _clear_bit(0);
+}
+inline ::google::protobuf::uint64 addressMappingSetResponse::new_version() const {
+ return new_version_;
+}
+inline void addressMappingSetResponse::set_new_version(::google::protobuf::uint64 value) {
+ _set_bit(0);
+ new_version_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// globalTimeSGetResponse
+
+// required fixed64 time_in_seconds = 1;
+inline bool globalTimeSGetResponse::has_time_in_seconds() const {
+ return _has_bit(0);
+}
+inline void globalTimeSGetResponse::clear_time_in_seconds() {
+ time_in_seconds_ = GOOGLE_ULONGLONG(0);
+ _clear_bit(0);
+}
+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);
+ time_in_seconds_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// serviceDeregisterRequest
+
+// required string uuid = 1;
+inline bool serviceDeregisterRequest::has_uuid() const {
+ return _has_bit(0);
+}
+inline void serviceDeregisterRequest::clear_uuid() {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(value);
+}
+inline void serviceDeregisterRequest::set_uuid(const char* value) {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ 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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* serviceDeregisterRequest::mutable_uuid() {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ uuid_ = new ::std::string;
+ }
+ return uuid_;
+}
+
+// -------------------------------------------------------------------
+
+// serviceGetByNameRequest
+
+// required string name = 1;
+inline bool serviceGetByNameRequest::has_name() const {
+ return _has_bit(0);
+}
+inline void serviceGetByNameRequest::clear_name() {
+ if (name_ != &_default_name_) {
+ name_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ name_ = new ::std::string;
+ }
+ name_->assign(value);
+}
+inline void serviceGetByNameRequest::set_name(const char* value) {
+ _set_bit(0);
+ if (name_ == &_default_name_) {
+ 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_) {
+ name_ = new ::std::string;
+ }
+ name_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* serviceGetByNameRequest::mutable_name() {
+ _set_bit(0);
+ if (name_ == &_default_name_) {
+ name_ = new ::std::string;
+ }
+ return name_;
+}
+
+// -------------------------------------------------------------------
+
+// serviceGetByUUIDRequest
+
+// required string name = 1;
+inline bool serviceGetByUUIDRequest::has_name() const {
+ return _has_bit(0);
+}
+inline void serviceGetByUUIDRequest::clear_name() {
+ if (name_ != &_default_name_) {
+ name_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ name_ = new ::std::string;
+ }
+ name_->assign(value);
+}
+inline void serviceGetByUUIDRequest::set_name(const char* value) {
+ _set_bit(0);
+ if (name_ == &_default_name_) {
+ 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_) {
+ name_ = new ::std::string;
+ }
+ name_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* serviceGetByUUIDRequest::mutable_name() {
+ _set_bit(0);
+ if (name_ == &_default_name_) {
+ name_ = new ::std::string;
+ }
+ return name_;
+}
+
+// -------------------------------------------------------------------
+
+// serviceGetByTypeRequest
+
+// required .xtreemfs.pbrpc.ServiceType type = 1;
+inline bool serviceGetByTypeRequest::has_type() const {
+ return _has_bit(0);
+}
+inline void serviceGetByTypeRequest::clear_type() {
+ type_ = 0;
+ _clear_bit(0);
+}
+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);
+ type_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// serviceRegisterRequest
+
+// required .xtreemfs.pbrpc.Service service = 1;
+inline bool serviceRegisterRequest::has_service() const {
+ return _has_bit(0);
+}
+inline void serviceRegisterRequest::clear_service() {
+ if (service_ != NULL) service_->::xtreemfs::pbrpc::Service::Clear();
+ _clear_bit(0);
+}
+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);
+ if (service_ == NULL) service_ = new ::xtreemfs::pbrpc::Service;
+ return service_;
+}
+
+// -------------------------------------------------------------------
+
+// serviceRegisterResponse
+
+// required fixed64 new_version = 1;
+inline bool serviceRegisterResponse::has_new_version() const {
+ return _has_bit(0);
+}
+inline void serviceRegisterResponse::clear_new_version() {
+ new_version_ = GOOGLE_ULONGLONG(0);
+ _clear_bit(0);
+}
+inline ::google::protobuf::uint64 serviceRegisterResponse::new_version() const {
+ return new_version_;
+}
+inline void serviceRegisterResponse::set_new_version(::google::protobuf::uint64 value) {
+ _set_bit(0);
+ new_version_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// configurationGetRequest
+
+// required string uuid = 1;
+inline bool configurationGetRequest::has_uuid() const {
+ return _has_bit(0);
+}
+inline void configurationGetRequest::clear_uuid() {
+ if (uuid_ != &_default_uuid_) {
+ uuid_->clear();
+ }
+ _clear_bit(0);
+}
+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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(value);
+}
+inline void configurationGetRequest::set_uuid(const char* value) {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ 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_) {
+ uuid_ = new ::std::string;
+ }
+ uuid_->assign(reinterpret_cast(value), size);
+}
+inline ::std::string* configurationGetRequest::mutable_uuid() {
+ _set_bit(0);
+ if (uuid_ == &_default_uuid_) {
+ uuid_ = new ::std::string;
+ }
+ return uuid_;
+}
+
+// -------------------------------------------------------------------
+
+// configurationSetResponse
+
+// optional fixed64 new_version = 1;
+inline bool configurationSetResponse::has_new_version() const {
+ return _has_bit(0);
+}
+inline void configurationSetResponse::clear_new_version() {
+ new_version_ = GOOGLE_ULONGLONG(0);
+ _clear_bit(0);
+}
+inline ::google::protobuf::uint64 configurationSetResponse::new_version() const {
+ return new_version_;
+}
+inline void configurationSetResponse::set_new_version(::google::protobuf::uint64 value) {
+ _set_bit(0);
+ new_version_ = value;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace pbrpc
+} // namespace xtreemfs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::ServiceType>() {
+ return xtreemfs::pbrpc::ServiceType_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< xtreemfs::pbrpc::ServiceStatus>() {
+ return xtreemfs::pbrpc::ServiceStatus_descriptor();
+}
+
+} // namespace google
+} // namespace protobuf
+#endif // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif // PROTOBUF_xtreemfs_2fDIR_2eproto__INCLUDED
diff --git a/cpp/generated/xtreemfs/DIRServiceClient.h b/cpp/generated/xtreemfs/DIRServiceClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad84b040d93dc04c0bf2e8240ae06ed025a8b580
--- /dev/null
+++ b/cpp/generated/xtreemfs/DIRServiceClient.h
@@ -0,0 +1,381 @@
+//automatically generated from DIR.proto at Fri Jul 22 16:47:12 CEST 2011
+//(c) 2011. See LICENSE file for details.
+
+#ifndef DIRSERVICECLIENT_H
+#define DIRSERVICECLIENT_H
+
+#include
+#include "pbrpc/RPC.pb.h"
+#include "rpc/client.h"
+#include "rpc/sync_callback.h"
+#include "rpc/callback_interface.h"
+#include "include/Common.pb.h"
+#include "xtreemfs/DIR.pb.h"
+
+
+namespace xtreemfs {
+ namespace pbrpc {
+ using ::xtreemfs::rpc::Client;
+ using ::xtreemfs::rpc::CallbackInterface;
+ using ::xtreemfs::rpc::SyncCallback;
+
+ class DIRServiceClient {
+
+ public:
+ DIRServiceClient(Client* client) : client_(client) {
+ }
+
+ virtual ~DIRServiceClient() {
+ }
+
+ void xtreemfs_address_mappings_get(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::addressMappingGetRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 1,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::AddressMappingSet(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_address_mappings_get_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::addressMappingGetRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 1,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::AddressMappingSet(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_address_mappings_remove(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::addressMappingGetRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 2,
+ creds, auth, request, data, data_length, NULL,
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_address_mappings_remove_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::addressMappingGetRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 2,
+ creds, auth, request, data, data_length, NULL,
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_address_mappings_set(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::AddressMappingSet* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 3,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::addressMappingSetResponse(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_address_mappings_set_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::AddressMappingSet* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 3,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::addressMappingSetResponse(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_discover_dir(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::emptyRequest* request = NULL;
+ client_->sendRequest(address, 10001, 4,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::DirService(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_discover_dir_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::emptyRequest* request = NULL;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 4,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::DirService(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_global_time_s_get(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::emptyRequest* request = NULL;
+ client_->sendRequest(address, 10001, 5,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::globalTimeSGetResponse(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_global_time_s_get_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::emptyRequest* request = NULL;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 5,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::globalTimeSGetResponse(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_service_deregister(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::serviceDeregisterRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 6,
+ creds, auth, request, data, data_length, NULL,
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_service_deregister_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::serviceDeregisterRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 6,
+ creds, auth, request, data, data_length, NULL,
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_service_get_by_name(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::serviceGetByNameRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 7,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_service_get_by_name_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::serviceGetByNameRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 7,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_service_get_by_type(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::serviceGetByTypeRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 8,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_service_get_by_type_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::serviceGetByTypeRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 8,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_service_get_by_uuid(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::serviceGetByUUIDRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 9,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_service_get_by_uuid_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::serviceGetByUUIDRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 9,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::ServiceSet(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_service_offline(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::serviceGetByUUIDRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 10,
+ creds, auth, request, data, data_length, NULL,
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_service_offline_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::serviceGetByUUIDRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 10,
+ creds, auth, request, data, data_length, NULL,
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_service_register(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::serviceRegisterRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 11,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::serviceRegisterResponse(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_service_register_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::serviceRegisterRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 11,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::serviceRegisterResponse(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_checkpoint(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::emptyRequest* request = NULL;
+ client_->sendRequest(address, 10001, 20,
+ creds, auth, request, data, data_length, NULL,
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_checkpoint_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::emptyRequest* request = NULL;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 20,
+ creds, auth, request, data, data_length, NULL,
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_shutdown(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::emptyRequest* request = NULL;
+ client_->sendRequest(address, 10001, 21,
+ creds, auth, request, data, data_length, NULL,
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_shutdown_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ xtreemfs::pbrpc::emptyRequest* request = NULL;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 21,
+ creds, auth, request, data, data_length, NULL,
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_configuration_get(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::configurationGetRequest* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 22,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::Configuration(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_configuration_get_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::configurationGetRequest* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 22,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::Configuration(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ void xtreemfs_configuration_set(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds,
+ const xtreemfs::pbrpc::Configuration* request,
+ CallbackInterface *callback, void *context = NULL) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ client_->sendRequest(address, 10001, 23,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::configurationSetResponse(),
+ context, callback);
+ }
+
+ SyncCallback* xtreemfs_configuration_set_sync(const std::string &address,
+ const xtreemfs::pbrpc::Auth& auth,
+ const xtreemfs::pbrpc::UserCredentials &creds
+ , const xtreemfs::pbrpc::Configuration* request) {
+ const char* data = NULL; boost::uint32_t data_length = 0;
+ SyncCallback* sync_cb = new SyncCallback();
+ client_->sendRequest(address, 10001, 23,
+ creds, auth, request, data, data_length, new xtreemfs::pbrpc::configurationSetResponse(),
+ NULL, sync_cb);
+ return sync_cb;
+ }
+
+ private:
+ Client* client_;
+ };
+ }
+}
+#endif //DIRSERVICECLIENT_H
diff --git a/cpp/generated/xtreemfs/GlobalTypes.pb.cc b/cpp/generated/xtreemfs/GlobalTypes.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f28c16c6c2003cde91d77efcd397bc0f6593a115
--- /dev/null
+++ b/cpp/generated/xtreemfs/GlobalTypes.pb.cc
@@ -0,0 +1,3895 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "xtreemfs/GlobalTypes.pb.h"
+#include