+for each user.
+
+In 'config.properties' you should add a list of directory
+services you would like to access with this console. Usually,
+this is only a single DIR, e.g.
+dir_servers = oncrpc://myDIRmachine:32638
+
+If you use SSL or GridSSL you have to use oncrpcs or oncrpcg instead.
+In addition, you have to configure which client certificate and
+which trusted certificates to use:
+ssl.service_creds = /etc/xos/xtreemfs/client.p12
+ssl.service_creds.pw = passphrase
+ssl.service_creds.container = pkcs12
+
+ssl.trusted_certs = /etc/xos/xtreemfs/trusted.jks
+ssl.trusted_certs.pw = passphrase
+ssl.trusted_certs.container = jks
+
+If you want to use google maps, you have to get a
+key from Google for your site and store it in
+google_maps_key = ABCDEFG...
+You don't need a key if you run the console on your local machine
+only.
diff --git a/trunk/contrib/console/XtreemFSConsole.war b/trunk/contrib/console/XtreemFSConsole.war
new file mode 100644
index 0000000000000000000000000000000000000000..1df0088d9af8c5ab3a898e275d84a081e331d45d
Binary files /dev/null and b/trunk/contrib/console/XtreemFSConsole.war differ
diff --git a/trunk/contrib/ganglia-plugin/.project b/trunk/contrib/ganglia-plugin/.project
new file mode 100644
index 0000000000000000000000000000000000000000..3714cb1cb1946452c8bf73d8b54a455e216d9cbd
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/.project
@@ -0,0 +1,17 @@
+
+
+ ganglia-plugin
+
+
+
+
+
+ org.python.pydev.PyDevBuilder
+
+
+
+
+
+ org.python.pydev.pythonNature
+
+
diff --git a/trunk/contrib/ganglia-plugin/.pydevproject b/trunk/contrib/ganglia-plugin/.pydevproject
new file mode 100644
index 0000000000000000000000000000000000000000..f8b45b0075e40eac3fc1c2412c55bbc007637ab4
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/.pydevproject
@@ -0,0 +1,10 @@
+
+
+
+
+Default
+python 2.6
+
+/ganglia-plugin/src
+
+
diff --git a/trunk/contrib/ganglia-plugin/README.txt b/trunk/contrib/ganglia-plugin/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3219512b26c2760906261a5b6ad9c66c0fd691cf
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/README.txt
@@ -0,0 +1,6 @@
+How to use this plugin?
+
+- Make sure your ganglia installation supports python plugins.
+- Copy plugin files from src directory to /usr/lib/ganglia/python_modules/
+- Copy configuration files configuration-files directory to /etc/ganglia/conf.d
+- Alter configuration files to suite your needs.
diff --git a/trunk/contrib/ganglia-plugin/config-files/xtfs-dir.pyconf b/trunk/contrib/ganglia-plugin/config-files/xtfs-dir.pyconf
new file mode 100644
index 0000000000000000000000000000000000000000..e74ff37214bd4490a0427b066988897b7740b6cc
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/config-files/xtfs-dir.pyconf
@@ -0,0 +1,62 @@
+modules {
+ module {
+ name = "xtfs-dir-plugin"
+ language = "python"
+ # The following params are examples only
+ # They are not actually used by the temp module
+ param Host {
+ value = localhost
+ }
+ param Port {
+ value = 9001
+ }
+ param CommunityString {
+ value = public
+ }
+ }
+}
+
+collection_group {
+ collect_every = 60
+ time_threshold = 10
+ metric {
+ name = "dir_jvm_used_mem"
+ title = "used memory of the jvm"
+ value_threshold = 1
+ }
+ metric {
+ name = "dir_jvm_free_mem"
+ title = "free memory of the jvm"
+ value_threshold = 1
+ }
+ metric {
+ name = "dir_client_connections"
+ title = "number of Clients"
+ value_threshold = 1
+ }
+ metric {
+ name = "dir_pending_requests"
+ title = "number of pending requests"
+ value_threshold = 1
+ }
+ metric {
+ name = "addr_mapping_count"
+ title = "number of address mappings"
+ value_threshold = 1
+ }
+ metric {
+ name = "service_count"
+ title = "number of services"
+ value_threshold = 1
+ }
+ metric {
+ name = "dir_status"
+ title = "Status DIR"
+ }
+ metric {
+ name = "dir_uuid"
+ title = "DIR UUID"
+ }
+}
+
+
diff --git a/trunk/contrib/ganglia-plugin/config-files/xtfs-mrc.pyconf b/trunk/contrib/ganglia-plugin/config-files/xtfs-mrc.pyconf
new file mode 100644
index 0000000000000000000000000000000000000000..8c083a85f23e89721e75bab84b37113d22c55036
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/config-files/xtfs-mrc.pyconf
@@ -0,0 +1,57 @@
+modules {
+ module {
+ name = "xtfs-mrc-plugin"
+ language = "python"
+ # The following params are examples only
+ # They are not actually used by the temp module
+ param Host {
+ value = localhost
+ }
+ param Port {
+ value = 9002
+ }
+ param CommunityString {
+ value = public
+ }
+ }
+}
+
+collection_group {
+ collect_every = 60
+ time_threshold = 10
+ metric {
+ name = "mrc_jvm_used_mem"
+ title = "used memory of the jvm"
+ value_threshold = 1
+ }
+ metric {
+ name = "mrc_jvm_free_mem"
+ title = "free memory of the jvm"
+ value_threshold = 1
+ }
+ metric {
+ name = "mrc_client_connections"
+ title = "number of Clients"
+ value_threshold = 1
+ }
+ metric {
+ name = "mrc_pending_requests"
+ title = "number of pending requests"
+ value_threshold = 1
+ }
+ metric {
+ name = "volumes_count"
+ title = "number of volumes"
+ value_threshold = 1
+ }
+ metric {
+ name = "mrc_status"
+ title = "Status MRC"
+ }
+ metric {
+ name = "mrc_uuid"
+ title = "MRC UUID"
+ }
+}
+
+
diff --git a/trunk/contrib/ganglia-plugin/config-files/xtfs-osd.pyconf b/trunk/contrib/ganglia-plugin/config-files/xtfs-osd.pyconf
new file mode 100644
index 0000000000000000000000000000000000000000..829369d26f317d97839c037844fba1520e9c17b9
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/config-files/xtfs-osd.pyconf
@@ -0,0 +1,108 @@
+modules {
+ module {
+ name = "xtfs-osd-plugin"
+ language = "python"
+ # The following params are examples only
+ # They are not actually used by the temp module
+ param Host {
+ value = localhost
+ }
+ param Port {
+ value = 9003
+ }
+ param CommunityString {
+ value = public
+ }
+ }
+}
+
+collection_group {
+ collect_every = 60
+ time_threshold = 10
+ metric {
+ name = "osd_jvm_used_mem"
+ title = "used memory of the jvm"
+ value_threshold = 1
+ }
+ metric {
+ name = "osd_jvm_free_mem"
+ title = "free memory of the jvm"
+ value_threshold = 1
+ }
+ metric {
+ name = "osd_client_connections"
+ title = "number of Clients"
+ value_threshold = 1
+ }
+ metric {
+ name = "objects_received"
+ title = "objects received"
+ value_threshold = 1
+ }
+ metric {
+ name = "repl_objects_received"
+ title = "replicated objects received"
+ value_threshold = 1
+ }
+ metric {
+ name = "objects_transmitted"
+ title = "objects transmitted"
+ value_threshold = 1
+ }
+ metric {
+ name = "repl_bytes_received"
+ title = "replicated bytes received"
+ value_threshold = 1
+ }
+ metric {
+ name = "bytes_received"
+ title = "bytes received"
+ value_threshold = 1
+ }
+ metric {
+ name = "bytes_transmitted"
+ title = "bytes transmitted"
+ value_threshold = 1
+ }
+ metric {
+ name = "preproc_queue_length"
+ title = "preprocessing stage queue length"
+ value_threshold = 1
+ }
+ metric {
+ name = "storage_queue_length"
+ title = "storage stage queue length"
+ value_threshold = 1
+ }
+ metric {
+ name = "deletion_queue_length"
+ title = "deletion stage queue length"
+ value_threshold = 1
+ }
+ metric {
+ name = "open_files"
+ title = "open files"
+ value_threshold = 1
+ }
+ metric {
+ name = "deleted_files"
+ title = "deleted files"
+ value_threshold = 1
+ }
+ metric {
+ name = "free_space"
+ title = "free space"
+ value_threshold = 100
+ }
+ metric {
+ name = "osd_status"
+ title = "Status OSD"
+ }
+ metric {
+ name = "osd_uuid"
+ title = "OSD UUID"
+ }
+}
+
+
+
\ No newline at end of file
diff --git a/trunk/contrib/ganglia-plugin/src/xtfs-dir-plugin.py b/trunk/contrib/ganglia-plugin/src/xtfs-dir-plugin.py
new file mode 100644
index 0000000000000000000000000000000000000000..32f40ab88272211fec92e9f212b67214dcd09d55
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/src/xtfs-dir-plugin.py
@@ -0,0 +1,250 @@
+'''
+Created on May 25, 2011
+
+@author: bzcseife
+
+This is a python ganglia plugin which monitors the status of an DIR service of the XtreemFS
+filesystem. It is intend to run on the same host as the DIR and gathers information of the DIR per
+SNMP. Therefore you have to configure your DIR to provide a SNMP Agent on this host.
+
+'''
+#TODO: If ganglia supports 64bit values uses 64bit integers instead of converting all 64 bit integers
+#reported from the SNMP Agent to 32bit integers.
+
+
+import random
+from pysnmp.entity.rfc3413.oneliner import cmdgen
+from pysnmp.entity.rfc3413.oneliner.cmdgen import UdpTransportTarget
+
+
+descriptors = list()
+Random_Max = 50
+Constant_Value = 50
+
+
+
+#Get the used memory of the JVM
+def JvmUsedMem(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 1, 0))
+ if (errorStatus == False and errorIndication == None):
+
+ return int(varBinds[0][1]/1024/1024)
+ else:
+ return 0
+#Get the free memory of the JVM
+def JvmFreeMem(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 2, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+#Get the number of client connections
+def ClientConnections(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 8, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+
+#Get the number of pending requests
+def PendingRequests(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 9, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#Get the number of address mappings registered
+def AddressMappingCount(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 2, 1, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#Get the number of services registered
+def ServiceCount(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 2, 2, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#get the status of the DIR
+#OID: 1.3.6.1.4.1.38350.1.11.0
+def Status(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 11, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return str(varBinds[0][1])
+ else:
+ return "OFFLINE"
+
+#get the UUID of the DIR
+#OID: 1.3.6.1.4.1.38350.1.13.0
+def Uuid(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 13, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return str(varBinds[0][1])
+ else:
+ return "Service not available"
+
+def metric_init(params):
+
+ global descriptors
+ global Commmunity_String
+ global Snmp_Port
+ global authData
+ global transportTarget
+
+
+ if 'ComummunityString' in params:
+ Community_String = params['CommunityString']
+ else:
+ Community_String = 'public'
+
+ if 'Port' in params:
+ Snmp_Port = int(params['Port'])
+ if 'Host' in params:
+ Snmp_Host = params['Host']
+
+ authData = cmdgen.CommunityData('xtreemfs-agent', 'public')
+ transportTarget = cmdgen.UdpTransportTarget((Snmp_Host, Snmp_Port), 1, 0)
+
+ d0 = {'name': 'dir_jvm_used_mem',
+ 'call_back': JvmUsedMem,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The amount of memory the JVM uses currently.',
+ 'groups': 'dir'}
+
+ d1 = {'name': 'dir_jvm_free_mem',
+ 'call_back': JvmFreeMem,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The amount of free memory the JVM can still use.',
+ 'groups': 'dir'}
+
+ d2 = {'name': 'dir_client_connections',
+ 'call_back': ClientConnections,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'clients',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of active client connection this DIR has currently to handle.',
+ 'groups': 'dir'}
+
+ d3 = {'name': 'dir_pending_requests',
+ 'call_back': PendingRequests,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'pending requests',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of pending requests this DIR has enqueued.',
+ 'groups': 'dir'}
+
+ d4 = {'name': 'addr_mapping_count',
+ 'call_back': AddressMappingCount,
+ 'time_max': 90,
+ #value_type: string | uint | float | double
+ 'value_type': 'uint',
+ #units: unit of your metric
+ 'units': 'mappings',
+ #slope: zero | positive | negative | both
+ #This value maps to the data source types defined for RRDTool
+ #If 'positive', RRD file generated will be of COUNTER type (calculating the rate of change)
+ #If 'negative', ????
+ #'both' will be of GAUGE type (no calculations are performed, graphing only the value reported)
+ #If 'zero', the metric will appear in the "Time and String Metrics" or the "Constant Metrics" depending on the value_type of the m
+ 'slope': 'both',
+ #format: format string of your metric
+ #Must correspond to value_type otherwise value of your metric will be unpredictable (reference: http://docs.python.org/library/stdtypes.html#string-formatting)
+ 'format': '%u',
+ #description: description of your metric
+ 'description': 'The number of address mapping registered at the DIR.',
+ #groups (optional): groups your metric belongs to
+ 'groups': 'dir'}
+
+ d5 = {'name': 'service_count',
+ 'call_back': ServiceCount,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'services',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of services registered at the DIR.',
+ 'groups': 'dir'}
+
+ d6 = {'name': 'dir_status',
+ 'call_back': Status,
+ 'time_max': 90,
+ 'value_type': 'string',
+ 'units': '',
+ 'slope': 'zero',
+ 'format': '%s',
+ 'description': 'ONLINE if this DIR is running correctly, OFFLINE otherwise',
+ 'groups': 'dir'}
+
+ d7 = {'name': 'dir_uuid',
+ 'call_back': Uuid,
+ 'time_max': 90,
+ 'value_type': 'string',
+ 'units': '',
+ 'slope': 'zero',
+ 'format': '%s',
+ 'description': 'UUID of the DIR running on this host',
+ 'groups': 'dir'}
+
+
+ descriptors = [d0, d1, d2, d3, d4, d5, d6, d7]
+
+ return descriptors
+
+def metric_cleanup():
+ '''Clean up the metric module.'''
+ pass
+
+
+#for debugging purpose
+if __name__ == '__main__':
+ params = {'CommunityString': 'public', 'Host': 'localhost', 'Port': 9001}
+ metric_init(params)
+ for d in descriptors:
+ v = d['call_back'](d['name'])
+ print 'value for %s is' % (d['name'])
+ print v
+
+
+
diff --git a/trunk/contrib/ganglia-plugin/src/xtfs-mrc-plugin.py b/trunk/contrib/ganglia-plugin/src/xtfs-mrc-plugin.py
new file mode 100644
index 0000000000000000000000000000000000000000..91bc39685de96006dab239a8e887c76912a64a41
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/src/xtfs-mrc-plugin.py
@@ -0,0 +1,221 @@
+'''
+Created on May 25, 2011
+
+@author: bzcseife
+
+This is a python ganglia plugin which monitors the status of an DIR service of the XtreemFS
+filesystem. It is intend to run on the same host as the MRC and gathers information of the MRC per
+SNMP. Therefore you have to configure your MRC to provide a SNMP Agent on this host.
+
+'''
+#TODO: If ganglia supports 64bit values uses 64bit integers instead of converting all 64 bit integers
+#reported from the SNMP Agent to 32bit integers.
+
+
+import random
+from pysnmp.entity.rfc3413.oneliner import cmdgen
+from pysnmp.entity.rfc3413.oneliner.cmdgen import UdpTransportTarget
+
+
+descriptors = list()
+Random_Max = 50
+Constant_Value = 50
+
+
+
+#Get the used memory of the JVM
+def JvmUsedMem(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 1, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+#Get the free memory of the JVM
+def JvmFreeMem(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 2, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+
+#Get the number of client connections
+def ClientConnections(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 7, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+
+#Get the number of pending requests
+def PendingRequests(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 8, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#Get the number of volumes
+def VolumeCount(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 3, 2, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#get the status of the MRC
+def Status(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 11, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return str(varBinds[0][1])
+ else:
+ return "OFFLINE"
+
+
+#get the UUID of the MRC
+#OID: 1.3.6.1.4.1.38350.1.13.0
+def Uuid(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 13, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return str(varBinds[0][1])
+ else:
+ return "Service not available"
+
+
+def metric_init(params):
+
+ global descriptors
+ global Commmunity_String
+ global Snmp_Port
+ global authData
+ global transportTarget
+
+
+ if 'ComummunityString' in params:
+ Community_String = params['CommunityString']
+ else:
+ Community_String = 'public'
+
+ if 'Port' in params:
+ Snmp_Port = int(params['Port'])
+ if 'Host' in params:
+ Snmp_Host = params['Host']
+
+ authData = cmdgen.CommunityData('xtreemfs-agent', 'public')
+ transportTarget = cmdgen.UdpTransportTarget((Snmp_Host, Snmp_Port),1 ,0)
+
+ d0 = {'name': 'mrc_jvm_used_mem',
+ 'call_back': JvmUsedMem,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The amount of memory the JVM uses currently.',
+ 'groups': 'mrc'}
+
+ d1 = {'name': 'mrc_jvm_free_mem',
+ 'call_back': JvmFreeMem,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The amount of free memory the JVM can still use.',
+ 'groups': 'mrc'}
+
+ d2 = {'name': 'mrc_client_connections',
+ 'call_back': ClientConnections,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'clients',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of active client connection this MRC has currently to handle.',
+ 'groups': 'mrc'}
+
+ d3 = {'name': 'mrc_pending_requests',
+ 'call_back': PendingRequests,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'pending requests',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of pending requests this MRC has enqueued.',
+ 'groups': 'mrc'}
+
+ d4 = {'name': 'volumes_count',
+ 'call_back': VolumeCount,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'volumes',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of volumes on this MRC.',
+ 'groups': 'mrc'}
+
+ d5 = {'name': 'mrc_status',
+ 'call_back': Status,
+ 'time_max': 90,
+ 'value_type': 'string',
+ 'units': '',
+ 'slope': 'zero',
+ 'format': '%s',
+ 'description': 'ONLINE if this OSD is running correctly, OFFLINE otherwise',
+ 'groups': 'mrc'}
+
+ d6 = {'name': 'mrc_uuid',
+ 'call_back': Uuid,
+ 'time_max': 90,
+ 'value_type': 'string',
+ 'units': '',
+ 'slope': 'zero',
+ 'format': '%s',
+ 'description': 'UUID of the MRC running on this host',
+ 'groups': 'mrc'}
+
+
+
+ descriptors = [d0, d1, d2, d3, d4, d5, d6 ]
+
+ return descriptors
+
+def metric_cleanup():
+ '''Clean up the metric module.'''
+ pass
+
+
+#for debugging purpose
+if __name__ == '__main__':
+ params = {'CommunityString': 'public', 'Host': 'localhost', 'Port': 9002}
+ metric_init(params)
+ for d in descriptors:
+ v = d['call_back'](d['name'])
+ print 'value for %s is ' % (d['name'])
+ print v
+
+
+
diff --git a/trunk/contrib/ganglia-plugin/src/xtfs-osd-plugin.py b/trunk/contrib/ganglia-plugin/src/xtfs-osd-plugin.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2fc7213f3db2e0a160f23a42880b8673c17abcb
--- /dev/null
+++ b/trunk/contrib/ganglia-plugin/src/xtfs-osd-plugin.py
@@ -0,0 +1,477 @@
+'''
+Created on May 25, 2011
+
+@author: bzcseife
+
+This is a python ganglia plugin which monitors the status of an OSD service of the XtreemFS
+filesystem. It is intend to run on the same host as the OSD and gathers information of the OSD per
+SNMP. Therefore you have to configure your OSD to provide a SNMP Agent on this host.
+
+'''
+#TODO: If ganglia supports 64bit values uses 64bit integers instead of converting all 64 bit integers
+#reported from the SNMP Agent to 32bit integers.
+
+
+import random
+from pysnmp.entity.rfc3413.oneliner import cmdgen
+from pysnmp.entity.rfc3413.oneliner.cmdgen import UdpTransportTarget
+
+
+
+
+descriptors = list()
+Random_Max = 50
+Constant_Value = 50
+
+
+
+#Get the used memory of the JVM
+def JvmUsedMem(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 1, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+
+
+#Get the free memory of the JVM
+def JvmFreeMem(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 2, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+
+#Get the number of client connections
+def ClientConnections(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 7, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+
+#Get the number of pending requests
+def PendingRequests(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 8, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#Get the number of objects received
+def ObjectsReceived(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 1, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#Get the number of replicated objects received
+def ReplObjectsReceived(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 2, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#Get the number of replicated objects transmitted
+def ObjectsTransmitted(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 3, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#Get the number of replicated bytes received
+def ReplBytesReceived(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 4, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+#Get the number of bytes received
+def BytesReceived(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 5, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+#Get the number of bytes transmitted
+def BytesTransmitted(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 6, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+#Get the length of the preprocessing stage queue
+def PreprocQueueLength(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 7, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+#Get the length of the storage stage queue
+def StorageQueueLength(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 8, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+#Get the length of the deletion stage queue
+def DeletionQueueLength(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 9, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+
+#Get the number of open files from the OSD per snmp
+def OsdOpenFiles(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 10, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+
+
+#Get the number of deleted files from the OSD per snmp
+def OsdDeletedFiles(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 11, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1])
+ else:
+ return 0
+
+
+#Get the free space from the OSD per snmp
+def OsdFreeSpace(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 4, 12, 0))
+ if (errorStatus == False and errorIndication == None):
+ return int(varBinds[0][1] / 1024 / 1024)
+ else:
+ return 0
+
+#get the status of the OSD
+def Status(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 11, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return str(varBinds[0][1])
+ else:
+ return "OFFLINE"
+
+#get the UUID of the OSD
+#OID: 1.3.6.1.4.1.38350.1.13.0
+def Uuid(name):
+ errorIndication, errorStatus, errorIndex, varBinds = cmdgen.CommandGenerator().getCmd(authData,
+ transportTarget,
+ (1, 3, 6, 1, 4, 1, 38350, 1, 13, 0))
+
+ if (errorStatus == False and errorIndication == None):
+ return str(varBinds[0][1])
+ else:
+ return "Service not available"
+
+def metric_init(params):
+
+ global descriptors
+ global Commmunity_String
+ global Snmp_Port
+ global authData
+ global transportTarget
+
+
+ if 'ComummunityString' in params:
+ Community_String = params['CommunityString']
+ else:
+ Community_String = 'public'
+
+ if 'Port' in params:
+ Snmp_Port = int(params['Port'])
+ if 'Host' in params:
+ Snmp_Host = params['Host']
+
+ authData = cmdgen.CommunityData('xtreemfs-agent', 'public')
+ transportTarget = cmdgen.UdpTransportTarget((Snmp_Host, Snmp_Port),1,0)
+
+ d0 = {'name': 'osd_jvm_used_mem',
+ 'call_back': JvmUsedMem,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The amount of memory the JVM uses currently.',
+ 'groups': 'osd'}
+
+ d1 = {'name': 'osd_jvm_free_mem',
+ 'call_back': JvmFreeMem,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The amount of free memory the JVM can still use.',
+ 'groups': 'osd'}
+
+ d2 = {'name': 'osd_client_connections',
+ 'call_back': ClientConnections,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'clients',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of active client connection this OSD has currently to handle.',
+ 'groups': 'osd'}
+
+ d3 = {'name': 'osd_pending_requests',
+ 'call_back': PendingRequests,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'pending requests',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of pending requests this OSD has enqueued.',
+ 'groups': 'osd'}
+
+ d4 = {'name': 'objects_received',
+ 'call_back': ObjectsReceived,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'objects',
+ 'slope': 'positive',
+ 'format': '%u',
+ 'description': 'The number of objects this OSD has received.',
+ 'groups': 'osd'}
+
+ d5 = {'name': 'repl_objects_received',
+ 'call_back': ReplObjectsReceived,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'objects',
+ 'slope': 'positive',
+ 'format': '%u',
+ 'description': 'The number of replicated objects this OSD has received.',
+ 'groups': 'osd'}
+
+ d6 = {'name': 'objects_transmitted',
+ 'call_back': ObjectsTransmitted,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'objects',
+ 'slope': 'positive',
+ 'format': '%u',
+ 'description': 'The number of objects this OSD has transmitted.',
+ 'groups': 'osd'}
+
+ d7 = {'name': 'repl_bytes_received',
+ 'call_back': ReplBytesReceived,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'positive',
+ 'format': '%u',
+ 'description': 'The number of replicated bytes this OSD has received.',
+ 'groups': 'osd'}
+
+ d8 = {'name': 'bytes_received',
+ 'call_back': BytesReceived,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'positive',
+ 'format': '%u',
+ 'description': 'The number of bytes this OSD has received.',
+ 'groups': 'osd'}
+
+ d9 = {'name': 'bytes_transmitted',
+ 'call_back': BytesTransmitted,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'Megabytes',
+ 'slope': 'positive',
+ 'format': '%u',
+ 'description': 'The number of bytes this OSD has transmitted.',
+ 'groups': 'osd'}
+
+ d10 = {'name': 'preproc_queue_length',
+ 'call_back': PreprocQueueLength,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'requests',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The length of the preprocessing stage queue of this OSD.',
+ 'groups': 'osd'}
+
+ d11 = {'name': 'storage_queue_length',
+ 'call_back': StorageQueueLength,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'requests',
+ 'slope': 'positive',
+ 'format': '%u',
+ 'description': 'The length of the storage stage queue of this OSD.',
+ 'groups': 'osd'}
+
+ d12 = {'name': 'deletion_queue_length',
+ 'call_back': DeletionQueueLength,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'requests',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The length of the deletion stage queue of this OSD.',
+ 'groups': 'osd'}
+
+ d13 = {'name': 'storage_queue_length',
+ 'call_back': StorageQueueLength,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'requests',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The length of the storage stage queue of this OSD.',
+ 'groups': 'osd'}
+
+ d14 = {'name': 'open_files',
+ 'call_back': OsdOpenFiles,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'files',
+ 'slope': 'both',
+ 'format': '%u',
+ 'description': 'The number of file this OSD has currently opened.',
+ 'groups': 'osd'}
+
+ d15 = {'name': 'deleted_files',
+ 'call_back': OsdDeletedFiles,
+ 'time_max': 90,
+ 'value_type': 'uint',
+ 'units': 'files',
+ 'slope': 'positive',
+ 'format': '%u',
+ 'description': 'The number of deleted files on this OSD',
+ 'groups': 'osd'}
+
+
+ d16 = {'name': 'free_space',
+ 'call_back': OsdFreeSpace,
+ 'time_max': 90,
+ #value_type: string | uint | float | double
+ 'value_type': 'uint',
+ #units: unit of your metric
+ 'units': 'Megabytes',
+ #slope: zero | positive | negative | both
+ #This value maps to the data source types defined for RRDTool
+ #If 'positive', RRD file generated will be of COUNTER type (calculating the rate of change)
+ #If 'negative', ????
+ #'both' will be of GAUGE type (no calculations are performed, graphing only the value reported)
+ #If 'zero', the metric will appear in the "Time and String Metrics" or the "Constant Metrics" depending on the value_type of the m
+ 'slope': 'both',
+ #format: format string of your metric
+ #Must correspond to value_type otherwise value of your metric will be unpredictable (reference: http://docs.python.org/library/stdtypes.html#string-formatting)
+ 'format': '%u',
+ #description: description of your metric
+ 'description': 'The free disc space on the partition this OSD stores the object files.',
+ #groups (optional): groups your metric belongs to
+ 'groups': 'osd'}
+
+ d17 = {'name': 'osd_status',
+ 'call_back': Status,
+ 'time_max': 90,
+ 'value_type': 'string',
+ 'units': '',
+ 'slope': 'zero',
+ 'format': '%s',
+ 'description': 'ONLINE if this OSD is running correctly, OFFLINE otherwise',
+ 'groups': 'osd'}
+
+ d18 = {'name': 'osd_uuid',
+ 'call_back': Uuid,
+ 'time_max': 90,
+ 'value_type': 'string',
+ 'units': '',
+ 'slope': 'zero',
+ 'format': '%s',
+ 'description': 'UUID of the OSD running on this host',
+ 'groups': 'osd'}
+
+ descriptors = [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18]
+
+ return descriptors
+
+def metric_cleanup():
+ '''Clean up the metric module.'''
+ pass
+
+
+#for debugging purpose
+if __name__ == '__main__':
+ params = {'CommunityString': 'public', 'Host': 'localhost', 'Port': 9003}
+ metric_init(params)
+ for d in descriptors:
+ v = d['call_back'](d['name'])
+ print 'value for %s is' % (d['name'])
+ print v
+
+
diff --git a/trunk/contrib/hadoop/build.xml b/trunk/contrib/hadoop/build.xml
new file mode 100644
index 0000000000000000000000000000000000000000..9ee471869a8d4668885950a02f5ee820c1233cf5
--- /dev/null
+++ b/trunk/contrib/hadoop/build.xml
@@ -0,0 +1,74 @@
+
+
+
+
+
+
+
+
+
+
+ Builds, tests, and runs the project HadoopClient.
+
+
+
diff --git a/trunk/contrib/hadoop/manifest.mf b/trunk/contrib/hadoop/manifest.mf
new file mode 100644
index 0000000000000000000000000000000000000000..328e8e5bc3b7f1f7bad2bc0751a933e00c801983
--- /dev/null
+++ b/trunk/contrib/hadoop/manifest.mf
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+X-COMMENT: Main-Class will be added automatically by build
+
diff --git a/trunk/contrib/hadoop/nbproject/build-impl.xml b/trunk/contrib/hadoop/nbproject/build-impl.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f2a0b2e6c7af54b01b54de41f2417b91e7fd737a
--- /dev/null
+++ b/trunk/contrib/hadoop/nbproject/build-impl.xml
@@ -0,0 +1,894 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must set src.dir
+ Must set test.src.dir
+ Must set build.dir
+ Must set dist.dir
+ Must set build.classes.dir
+ Must set dist.javadoc.dir
+ Must set build.test.classes.dir
+ Must set build.test.results.dir
+ Must set build.classes.excludes
+ Must set dist.jar
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must set javac.includes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select some files in the IDE or set javac.includes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ To run this application from the command line without Ant, try:
+
+
+
+
+
+
+ java -cp "${run.classpath.with.dist.jar}" ${main.class}
+
+
+
+
+
+
+
+
+
+
+
+ To run this application from the command line without Ant, try:
+
+ java -jar "${dist.jar.resolved}"
+
+
+
+
+
+
+
+ To run this application from the command line without Ant, try:
+
+ java -jar "${dist.jar.resolved}"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set run.class
+
+
+
+ Must select one file in the IDE or set run.class
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set debug.class
+
+
+
+
+ Must select one file in the IDE or set debug.class
+
+
+
+
+ Must set fix.includes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select some files in the IDE or set javac.includes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Some tests failed; see details above.
+
+
+
+
+
+
+
+
+ Must select some files in the IDE or set test.includes
+
+
+
+ Some tests failed; see details above.
+
+
+
+
+ Must select one file in the IDE or set test.class
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set applet.url
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set applet.url
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/trunk/contrib/hadoop/nbproject/genfiles.properties b/trunk/contrib/hadoop/nbproject/genfiles.properties
new file mode 100644
index 0000000000000000000000000000000000000000..763766440925abb444ba22f56e4ad1aac095f849
--- /dev/null
+++ b/trunk/contrib/hadoop/nbproject/genfiles.properties
@@ -0,0 +1,8 @@
+build.xml.data.CRC32=f7795631
+build.xml.script.CRC32=306b2296
+build.xml.stylesheet.CRC32=28e38971@1.38.3.45
+# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
+# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
+nbproject/build-impl.xml.data.CRC32=f7795631
+nbproject/build-impl.xml.script.CRC32=df3692d9
+nbproject/build-impl.xml.stylesheet.CRC32=229523de@1.38.3.45
diff --git a/trunk/contrib/hadoop/nbproject/project.properties b/trunk/contrib/hadoop/nbproject/project.properties
new file mode 100644
index 0000000000000000000000000000000000000000..4ac4e8373083f5b0cbed4ba27da9bc4e825a8c72
--- /dev/null
+++ b/trunk/contrib/hadoop/nbproject/project.properties
@@ -0,0 +1,79 @@
+annotation.processing.enabled=true
+annotation.processing.enabled.in.editor=false
+annotation.processing.run.all.processors=true
+application.title=HadoopClient
+application.vendor=bjko
+build.classes.dir=${build.dir}/classes
+build.classes.excludes=**/*.java,**/*.form
+# This directory is removed when the project is cleaned:
+build.dir=build
+build.generated.dir=${build.dir}/generated
+build.generated.sources.dir=${build.dir}/generated-sources
+# Only compile against the classpath explicitly listed here:
+build.sysclasspath=ignore
+build.test.classes.dir=${build.dir}/test/classes
+build.test.results.dir=${build.dir}/test/results
+# Uncomment to specify the preferred debugger connection transport:
+#debug.transport=dt_socket
+debug.classpath=\
+ ${run.classpath}
+debug.test.classpath=\
+ ${run.test.classpath}
+# This directory is removed when the project is cleaned:
+dist.dir=dist
+dist.jar=${dist.dir}/HadoopClient.jar
+dist.javadoc.dir=${dist.dir}/javadoc
+endorsed.classpath=
+excludes=
+file.reference.Foundation.jar=../../java/foundation/dist/Foundation.jar
+file.reference.hadoop-core-0.20.203.0.jar=../../../../Downloads/hadoop-0.20.203.0/hadoop-core-0.20.203.0.jar
+file.reference.protobuf-java-2.3.0.jar=../../java/lib/protobuf-java-2.3.0.jar
+file.reference.XtreemFS.jar=../../java/servers/dist/XtreemFS.jar
+includes=**
+jar.compress=false
+javac.classpath=\
+ ${file.reference.Foundation.jar}:\
+ ${file.reference.hadoop-core-0.20.203.0.jar}:\
+ ${file.reference.protobuf-java-2.3.0.jar}:\
+ ${file.reference.XtreemFS.jar}
+
+# Space-separated list of extra javac options
+javac.compilerargs=
+javac.deprecation=false
+javac.processorpath=\
+ ${javac.classpath}
+javac.source=1.5
+javac.target=1.5
+javac.test.classpath=\
+ ${javac.classpath}:\
+ ${build.classes.dir}:\
+ ${libs.junit.classpath}:\
+ ${libs.junit_4.classpath}
+javadoc.additionalparam=
+javadoc.author=false
+javadoc.encoding=${source.encoding}
+javadoc.noindex=false
+javadoc.nonavbar=false
+javadoc.notree=false
+javadoc.private=false
+javadoc.splitindex=true
+javadoc.use=true
+javadoc.version=false
+javadoc.windowtitle=
+main.class=
+manifest.file=manifest.mf
+meta.inf.dir=${src.dir}/META-INF
+platform.active=default_platform
+run.classpath=\
+ ${javac.classpath}:\
+ ${build.classes.dir}
+# Space-separated list of JVM arguments used when running the project
+# (you may also define separate properties like run-sys-prop.name=value instead of -Dname=value
+# or test-sys-prop.name=value to set system properties for unit tests):
+run.jvmargs=
+run.test.classpath=\
+ ${javac.test.classpath}:\
+ ${build.test.classes.dir}
+source.encoding=UTF-8
+src.dir=src
+test.src.dir=test
diff --git a/trunk/contrib/hadoop/nbproject/project.xml b/trunk/contrib/hadoop/nbproject/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..de48e4eeb966ec05d1eb25b3bc5eb86c4a350477
--- /dev/null
+++ b/trunk/contrib/hadoop/nbproject/project.xml
@@ -0,0 +1,16 @@
+
+
+ org.netbeans.modules.java.j2seproject
+
+
+ HadoopClient
+
+
+
+
+
+
+
+
+
+
diff --git a/trunk/contrib/hadoop/nbproject/protobuf-build.cfg.xml b/trunk/contrib/hadoop/nbproject/protobuf-build.cfg.xml
new file mode 100644
index 0000000000000000000000000000000000000000..fe07f640916a8975e70337227eb06690827e1fd4
--- /dev/null
+++ b/trunk/contrib/hadoop/nbproject/protobuf-build.cfg.xml
@@ -0,0 +1,2 @@
+
+
\ No newline at end of file
diff --git a/trunk/contrib/hadoop/nbproject/protobuf-build.xml b/trunk/contrib/hadoop/nbproject/protobuf-build.xml
new file mode 100644
index 0000000000000000000000000000000000000000..4bd04501b5481d2a9587b64489cef3eaeb550ee0
--- /dev/null
+++ b/trunk/contrib/hadoop/nbproject/protobuf-build.xml
@@ -0,0 +1,24 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/trunk/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileSystem.java b/trunk/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileSystem.java
new file mode 100644
index 0000000000000000000000000000000000000000..eef9e9c9613967a12944d32d9aa929bc702755f5
--- /dev/null
+++ b/trunk/contrib/hadoop/src/org/xtreemfs/common/clients/hadoop/XtreemFSFileSystem.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 2009-2011 by Bjoern Kolbeck,
+ * Zuse Institute Berlin
+ *
+ * Licensed under the BSD License, see LICENSE file for details.
+ *
+ */
+
+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.foundation.pbrpc.generatedinterfaces.RPC.UserCredentials;
+import org.xtreemfs.pbrpc.generatedinterfaces.GlobalTypes;
+import org.xtreemfs.pbrpc.generatedinterfaces.MRC.DirectoryEntry;
+import org.xtreemfs.pbrpc.generatedinterfaces.MRC.Stat;
+
+/**
+ * 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 in" +
+ " 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.Builder ucBuilder = UserCredentials.newBuilder();
+ UserCredentials uc = null;
+ if ( (conf.get("xtreemfs.client.userid") != null)
+ && (conf.get("xtreemfs.client.groupid") != null) ){
+ uc = UserCredentials.newBuilder().
+ setUsername(conf.get("xtreemfs.client.userid")).
+ addGroups(conf.get("xtreemfs.client.groupid")).build();
+ }
+ if (uc == null) {
+ //try to guess from env
+ if (System.getenv("USER") != null) {
+ uc = UserCredentials.newBuilder().
+ setUsername(System.getProperty("user.name")).
+ addGroups("users").build();
+ }
+ }
+
+ 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();
+ final boolean isDir = (s.getMode() & GlobalTypes.SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_S_IFDIR.getNumber()) > 0;
+ fslist[i] = new FileStatus(s.getSize(), isDir , 1, 1,(long) (s.getMtimeNs() / 1e6),
+ (long) (s.getAtimeNs() / 1e6), new FsPermission((short)s.getMode()),
+ s.getUserId(), s.getGroupId(), 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() & GlobalTypes.SYSTEM_V_FCNTL.SYSTEM_V_FCNTL_H_S_IFDIR.getNumber()) > 0;
+ return new FileStatus(s.getSize(), isDir , 1, 1,(long) (s.getMtimeNs() / 1e6),
+ (long) (s.getAtimeNs() / 1e6), new FsPermission((short)s.getMode()),
+ s.getUserId(), s.getGroupId(), file);
+ }
+
+ public void close() {
+ xtreemfsClient.stop();
+ }
+}
diff --git a/trunk/contrib/server-repl-plugin/LICENSE b/trunk/contrib/server-repl-plugin/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2f354973f2818748843772adc5b1d0c9e88d1191
--- /dev/null
+++ b/trunk/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/trunk/contrib/server-repl-plugin/README b/trunk/contrib/server-repl-plugin/README
new file mode 100644
index 0000000000000000000000000000000000000000..c364af4131bed0c855f8e95dddc5ca52886761c9
--- /dev/null
+++ b/trunk/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/trunk/contrib/server-repl-plugin/config/dir-test1.properties b/trunk/contrib/server-repl-plugin/config/dir-test1.properties
new file mode 100644
index 0000000000000000000000000000000000000000..14343213b26b25ac926438b7e1f8417cf56bd330
--- /dev/null
+++ b/trunk/contrib/server-repl-plugin/config/dir-test1.properties
@@ -0,0 +1,64 @@
+#####################################################################
+# 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.
+# WriteRestriction - will only permit lookup operations at the slaves. Any other kind of request is
+# redirected 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
+
+# decides whether redirects should be handled by the user-application or not
+#babudb.repl.redirectIsVisible = false
\ No newline at end of file
diff --git a/trunk/contrib/server-repl-plugin/config/dir-test2.properties b/trunk/contrib/server-repl-plugin/config/dir-test2.properties
new file mode 100644
index 0000000000000000000000000000000000000000..2230c60f88c918436d53ca932bd74325ea2eead9
--- /dev/null
+++ b/trunk/contrib/server-repl-plugin/config/dir-test2.properties
@@ -0,0 +1,64 @@
+#####################################################################
+# 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.
+# WriteRestriction - will only permit lookup operations at the slaves. Any other kind of request is
+# redirected 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
+
+# decides whether redirects should be handled by the user-application or not
+#babudb.repl.redirectIsVisible = false
\ No newline at end of file
diff --git a/trunk/contrib/server-repl-plugin/config/dir.properties b/trunk/contrib/server-repl-plugin/config/dir.properties
new file mode 100644
index 0000000000000000000000000000000000000000..41f1eb7f0693cea3c03935847ec417f5a7dda9c2
--- /dev/null
+++ b/trunk/contrib/server-repl-plugin/config/dir.properties
@@ -0,0 +1,64 @@
+#####################################################################
+# BabuDB replication plugin configuration #
+#####################################################################
+
+plugin.jar = /usr/share/xtreemfs/server-repl-plugin/replication.jar
+
+# paths to libraries this plugin depends on
+babudb.repl.dependency.0 = /usr/share/xtreemfs/server-repl-plugin/lib/PBRPC.jar
+babudb.repl.dependency.1 = /usr/share/xtreemfs/server-repl-plugin/lib/Flease.jar
+babudb.repl.dependency.2 = /usr/share/xtreemfs/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 = /var/lib/xtreemfs/server-repl-dir
+
+# 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.
+# WriteRestriction - will only permit lookup operations at the slaves. Any other kind of request is
+# redirected 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 = 35678
+
+# 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 = 35678
+babudb.repl.participant.1 = somehost
+babudb.repl.participant.1.port = 35678
+
+# 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
+
+# decides whether redirects should be handled by the user-application or not
+#babudb.repl.redirectIsVisible = false
\ No newline at end of file
diff --git a/trunk/contrib/server-repl-plugin/config/mrc-test1.properties b/trunk/contrib/server-repl-plugin/config/mrc-test1.properties
new file mode 100644
index 0000000000000000000000000000000000000000..572f1bac5d0887689a0bde1392ac9cfab6158b7b
--- /dev/null
+++ b/trunk/contrib/server-repl-plugin/config/mrc-test1.properties
@@ -0,0 +1,66 @@
+#####################################################################
+# 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.
+# WriteRestriction - will only permit lookup operations at the slaves. Any other kind of request is
+# redirected 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 = 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
+babudb.repl.participant.2 = localhost
+babudb.repl.participant.2.port = 35665
+
+# 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
+
+# decides whether redirects should be handled by the user-application or not
+#babudb.repl.redirectIsVisible = false
\ No newline at end of file
diff --git a/trunk/contrib/server-repl-plugin/config/mrc-test2.properties b/trunk/contrib/server-repl-plugin/config/mrc-test2.properties
new file mode 100644
index 0000000000000000000000000000000000000000..41459f606de87392afe0eed3528f811a4e7bd6d6
--- /dev/null
+++ b/trunk/contrib/server-repl-plugin/config/mrc-test2.properties
@@ -0,0 +1,66 @@
+#####################################################################
+# 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.
+# WriteRestriction - will only permit lookup operations at the slaves. Any other kind of request is
+# redirected 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 = 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
+babudb.repl.participant.2 = localhost
+babudb.repl.participant.2.port = 35665
+
+# 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
+
+# decides whether redirects should be handled by the user-application or not
+#babudb.repl.redirectIsVisible = false
\ No newline at end of file
diff --git a/trunk/contrib/server-repl-plugin/config/mrc-test3.properties b/trunk/contrib/server-repl-plugin/config/mrc-test3.properties
new file mode 100644
index 0000000000000000000000000000000000000000..b2840c13631da7475b93ca2b3d8966a26488caa0
--- /dev/null
+++ b/trunk/contrib/server-repl-plugin/config/mrc-test3.properties
@@ -0,0 +1,66 @@
+#####################################################################
+# 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-mrc3/
+
+# 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.
+# WriteRestriction - will only permit lookup operations at the slaves. Any other kind of request is
+# redirected 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 = 35665
+
+# 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
+babudb.repl.participant.2 = localhost
+babudb.repl.participant.2.port = 35665
+
+# 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
+
+# decides whether redirects should be handled by the user-application or not
+#babudb.repl.redirectIsVisible = false
\ No newline at end of file
diff --git a/trunk/contrib/server-repl-plugin/config/mrc.properties b/trunk/contrib/server-repl-plugin/config/mrc.properties
new file mode 100644
index 0000000000000000000000000000000000000000..8f48f48ddb7d9390fd350d6022f003c1edafc55b
--- /dev/null
+++ b/trunk/contrib/server-repl-plugin/config/mrc.properties
@@ -0,0 +1,64 @@
+#####################################################################
+# BabuDB replication plugin configuration #
+#####################################################################
+
+plugin.jar = /usr/share/xtreemfs/server-repl-plugin/replication.jar
+
+# paths to libraries this plugin depends on
+babudb.repl.dependency.0 = /usr/share/xtreemfs/server-repl-plugin/lib/PBRPC.jar
+babudb.repl.dependency.1 = /usr/share/xtreemfs/server-repl-plugin/lib/Flease.jar
+babudb.repl.dependency.2 = /usr/share/xtreemfs/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 = /var/lib/xtreemfs/server-repl-mrc
+
+# 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.
+# WriteRestriction - will only permit lookup operations at the slaves. Any other kind of request is
+# redirected 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 = 35676
+babudb.repl.participant.1 = somehost
+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
+
+# decides whether redirects should be handled by the user-application or not
+#babudb.repl.redirectIsVisible = false
\ No newline at end of file
diff --git a/trunk/contrib/server-repl-plugin/lib/Flease.jar b/trunk/contrib/server-repl-plugin/lib/Flease.jar
new file mode 100644
index 0000000000000000000000000000000000000000..aa75be12a40a6accbe739d6802def7e8ab3bbe9f
Binary files /dev/null and b/trunk/contrib/server-repl-plugin/lib/Flease.jar differ
diff --git a/trunk/contrib/server-repl-plugin/lib/PBRPC.jar b/trunk/contrib/server-repl-plugin/lib/PBRPC.jar
new file mode 100644
index 0000000000000000000000000000000000000000..9300fc0c825999e1296246cd0b8fd6b809a3eeb0
Binary files /dev/null and b/trunk/contrib/server-repl-plugin/lib/PBRPC.jar differ
diff --git a/trunk/contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar b/trunk/contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar
new file mode 100644
index 0000000000000000000000000000000000000000..3c87f156dfed4412778a5cddee79db26593fea88
Binary files /dev/null and b/trunk/contrib/server-repl-plugin/lib/protobuf-java-2.3.0.jar differ
diff --git a/trunk/contrib/server-repl-plugin/replication.jar b/trunk/contrib/server-repl-plugin/replication.jar
new file mode 100644
index 0000000000000000000000000000000000000000..ab47ff49823df26f7281d95b74dfcc559be431a3
Binary files /dev/null and b/trunk/contrib/server-repl-plugin/replication.jar differ
diff --git a/trunk/cpp/.cproject b/trunk/cpp/.cproject
new file mode 100644
index 0000000000000000000000000000000000000000..267d5f0290044a1b96d44562b2645b21bc384d36
--- /dev/null
+++ b/trunk/cpp/.cproject
@@ -0,0 +1,85 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/trunk/cpp/.project b/trunk/cpp/.project
new file mode 100644
index 0000000000000000000000000000000000000000..2621dd10a02ae9272d25d7e81aab9a4235eadbd9
--- /dev/null
+++ b/trunk/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:/xtreemfs_trunk_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/trunk/cpp/CMakeLists.txt b/trunk/cpp/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7e2d4d894b93508c5b7ecfad555cf9980e4c454e
--- /dev/null
+++ b/trunk/cpp/CMakeLists.txt
@@ -0,0 +1,146 @@
+cmake_minimum_required(VERSION 2.6)
+PROJECT(cpp CXX)
+set(BUILD_CLIENT_TESTS $ENV{BUILD_CLIENT_TESTS})
+
+#SET (CMAKE_VERBOSE_MAKEFILE true)
+
+add_definitions(-D_FILE_OFFSET_BITS=64)
+
+# Set variables and required libraries.
+##########################################
+set(CMAKE_CXX_FLAGS "-Wall -Wno-unused-function -Wno-sign-compare")
+
+# Set paths for required thirdparty libraries.
+set(CLIENT_GOOGLE_PROTOBUF_CPP "${CMAKE_SOURCE_DIR}/thirdparty/protobuf-2.3.0")
+set(CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY "${CLIENT_GOOGLE_PROTOBUF_CPP}/src/.libs/libprotobuf.a")
+set(CLIENT_GOOGLE_TEST_CPP "${CMAKE_SOURCE_DIR}/thirdparty/gtest-1.5.0")
+set(CLIENT_GOOGLE_TEST_CPP_LIBRARY "${CLIENT_GOOGLE_TEST_CPP}/lib/.libs/libgtest.a")
+set(CLIENT_GOOGLE_TEST_CPP_MAIN "${CLIENT_GOOGLE_TEST_CPP}/lib/.libs/libgtest_main.a")
+
+# Set required libraries.
+set(LIBFUSE "fuse")
+SET(LIBATTR "attr")
+IF(APPLE)
+ # No libattr on mac.
+ SET(LIBATTR "")
+ # On Apple we use the environment variable BOOST_ROOT to point to a local boost installation and we link the built boost libraries statically.
+ SET(Boost_USE_STATIC_LIBS true)
+ # Update 8/12/2011: Setting macosx-version-min does break mount.xtreemfs for unknown reasons - so disabled for now.
+ # Tell gcc to compile 10.4 compatible files (does not work otherwise on older Macs).
+ #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.4")
+ENDIF(APPLE)
+
+# Set required thirdparty libraries.
+# Finding the boost libraries may fail. If existing, we point FIND_PACKAGE to /usr/lib64.
+if(EXISTS "/usr/lib64/libboost_system.so")
+ set(BOOST_LIBRARYDIR "/usr/lib64")
+endif(EXISTS "/usr/lib64/libboost_system.so")
+FIND_PACKAGE(Boost COMPONENTS system thread program_options regex REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
+if (NOT Boost_FOUND)
+ message(FATAL_ERROR "The boost library was not found on your system. If needed, you can also download and compile it on your own. After compiling boost locally, set the the environment variable BOOST_ROOT to the boost base directory, e.g. export BOOST_ROOT=/Users/xyz/boost_1_47_0.")
+endif(NOT Boost_FOUND)
+
+
+SET(REQUIRED_STATIC_LIBRARIES ${CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY})
+if(BUILD_CLIENT_TESTS)
+ SET(REQUIRED_STATIC_LIBRARIES ${REQUIRED_STATIC_LIBRARIES} ${CLIENT_GOOGLE_TEST_CPP_LIBRARY} ${CLIENT_GOOGLE_TEST_CPP_MAIN})
+endif(BUILD_CLIENT_TESTS)
+
+foreach (STATIC_LIB_FULL_PATH ${REQUIRED_STATIC_LIBRARIES})
+ if(NOT EXISTS ${STATIC_LIB_FULL_PATH})
+ message(FATAL_ERROR "The file ${STATIC_LIB_FULL_PATH} was not found. Please run 'make client' or 'make' from the base directory in order to build the required static libraries.")
+ endif()
+endforeach(STATIC_LIB_FULL_PATH)
+
+CMAKE_POLICY(SET CMP0003 OLD)
+ADD_LIBRARY(protobuf STATIC IMPORTED)
+SET_PROPERTY(TARGET protobuf PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_PROTOBUF_CPP_LIBRARY})
+include_directories(${CLIENT_GOOGLE_PROTOBUF_CPP}/src)
+
+ADD_LIBRARY(gtest STATIC IMPORTED)
+ADD_LIBRARY(gtest_main STATIC IMPORTED)
+SET_PROPERTY(TARGET gtest PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_TEST_CPP_LIBRARY})
+SET_PROPERTY(TARGET gtest_main PROPERTY IMPORTED_LOCATION ${CLIENT_GOOGLE_TEST_CPP_MAIN})
+include_directories(${CLIENT_GOOGLE_TEST_CPP}/include)
+
+# Check if this is a 64 Bit system
+if(UNIX AND NOT WIN32)
+ if(CMAKE_SIZEOF_VOID_P MATCHES "8")
+ if(APPLE)
+ set(LIBFUSE "fuse_ino64")
+ endif(APPLE)
+ endif(CMAKE_SIZEOF_VOID_P MATCHES "8")
+endif(UNIX AND NOT WIN32)
+
+SET(REQUIRED_LIBRARIES ${LIBFUSE} ${LIBATTR} "crypto" "ssl" "pthread")
+foreach(LIB ${REQUIRED_LIBRARIES})
+ #message(STATUS "checking for library: ${LIB}")
+ # For unknown reasons, setting "FIND_LIBRARY_USE_LIB64_PATHS" does not fix the issue that libraries in /usr/lib64/ are not found under openSuse.
+ # Therefore we just specify a list of possible library directories.
+ find_library(FOUND${LIB} ${LIB} PATHS "/lib64" "/usr/lib64")
+ if (NOT FOUND${LIB})
+ message(FATAL_ERROR "The required library '${LIB}' was not found. Please install it on your system first.")
+ #else()
+ # message(STATUS "Result of find_library: ${FOUND${LIB}}")
+ endif(NOT FOUND${LIB})
+endforeach(LIB)
+
+# Define building of binaries.
+##########################################
+MESSAGE(STATUS "Configuring XtreemFS client (libxtreemfs, FuseAdapter(mount.xtreemfs) and Volume Tools ({mkfs,rmfs,lsfs}.xtreemfs).")
+
+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})
+
+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 ${LIBFUSE})
+
+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)
+
+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)
+
+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)
+
+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} ${LIBATTR})
+
+# Define building of unittests.
+##########################################
+if(BUILD_CLIENT_TESTS)
+ # enable_testing() will provide a target "test".
+ enable_testing()
+
+ MESSAGE(STATUS "Configuring libxtreemfs unittests.")
+
+ 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(IS_DIRECTORY ${testdir})
+ endforeach(testdir)
+endif(BUILD_CLIENT_TESTS)
diff --git a/trunk/cpp/Doxyfile b/trunk/cpp/Doxyfile
new file mode 100644
index 0000000000000000000000000000000000000000..07fd28c7654ef9e4c19f485e2aba293d5c05c70f
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/.dep.inc b/trunk/cpp/cpp_prj/.dep.inc
new file mode 100644
index 0000000000000000000000000000000000000000..4560e55af987875b237a8ceb4c29b383c6575292
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/cpp_prj-Makefile.mk b/trunk/cpp/cpp_prj/cpp_prj-Makefile.mk
new file mode 100644
index 0000000000000000000000000000000000000000..ec9de690e53a4d149efe22428359088b44605367
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/nbproject/Makefile-Default.mk b/trunk/cpp/cpp_prj/nbproject/Makefile-Default.mk
new file mode 100644
index 0000000000000000000000000000000000000000..f763f28d2ae61e0b65a646f2b4702c91ac8d7b3b
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/nbproject/Makefile-impl.mk b/trunk/cpp/cpp_prj/nbproject/Makefile-impl.mk
new file mode 100644
index 0000000000000000000000000000000000000000..41e48c2284a1acaa6d7193413d306c2e3ca4ec29
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/nbproject/Makefile-variables.mk b/trunk/cpp/cpp_prj/nbproject/Makefile-variables.mk
new file mode 100644
index 0000000000000000000000000000000000000000..1dd487ffa8ba46b92e716c5a74b157009bd24818
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/nbproject/Package-Default.bash b/trunk/cpp/cpp_prj/nbproject/Package-Default.bash
new file mode 100644
index 0000000000000000000000000000000000000000..d994f7522674ff6a39d66dcff91662496696d324
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/nbproject/configurations.xml b/trunk/cpp/cpp_prj/nbproject/configurations.xml
new file mode 100644
index 0000000000000000000000000000000000000000..28dce16f1c14a06799b945e9fee7878c930e1f37
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/nbproject/private/configurations.xml b/trunk/cpp/cpp_prj/nbproject/private/configurations.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3a36d13c6c65844bdf32b29dd33619dbc46f2992
--- /dev/null
+++ b/trunk/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/trunk/cpp/cpp_prj/nbproject/private/private.properties b/trunk/cpp/cpp_prj/nbproject/private/private.properties
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/trunk/cpp/cpp_prj/nbproject/private/private.xml b/trunk/cpp/cpp_prj/nbproject/private/private.xml
new file mode 100644
index 0000000000000000000000000000000000000000..bf91c93b1afbafb034105ed94fe08abd67a24447
--- /dev/null
+++ b/trunk/cpp/cpp_prj/nbproject/private/private.xml
@@ -0,0 +1,7 @@
+
+
+
+ true
+
+
+
diff --git a/trunk/cpp/cpp_prj/nbproject/project.properties b/trunk/cpp/cpp_prj/nbproject/project.properties
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/trunk/cpp/cpp_prj/nbproject/project.xml b/trunk/cpp/cpp_prj/nbproject/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..fa8dde0b89f980781499125b246cf7b3dcc65e75
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/include/Common.pb.cc b/trunk/cpp/generated/include/Common.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e65bf7af01f07c0083ab783b1baf8a067607fede
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/include/Common.pb.h b/trunk/cpp/generated/include/Common.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..c05902c887c7ef3651277becbc3aa915f6617d9f
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/include/PBRPC.pb.cc b/trunk/cpp/generated/include/PBRPC.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6e4f642af327cc8f1793a893ba58fa4064320d8a
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/include/PBRPC.pb.h b/trunk/cpp/generated/include/PBRPC.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..880206c5081c7652d28d931b9522a61aed629671
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/pbrpc/CMakeLists.txt b/trunk/cpp/generated/pbrpc/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/trunk/cpp/generated/pbrpc/Ping.pb.cc b/trunk/cpp/generated/pbrpc/Ping.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9f44e8f7dc1b02516cd2072d2444c4f95b9ac9c7
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/pbrpc/Ping.pb.h b/trunk/cpp/generated/pbrpc/Ping.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0f02e7da923016892aa6f626fab4872ab1693e2
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/pbrpc/PingServiceClient.h b/trunk/cpp/generated/pbrpc/PingServiceClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..634a9080abe9e4059e8f56e44e09afaa61df9c4a
--- /dev/null
+++ b/trunk/cpp/generated/pbrpc/PingServiceClient.h
@@ -0,0 +1,79 @@
+//automatically generated from Ping.proto at Mon Aug 01 16:12:45 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/trunk/cpp/generated/pbrpc/RPC.pb.cc b/trunk/cpp/generated/pbrpc/RPC.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bb8168e29e24a554efe9058d903b805211f7038d
--- /dev/null
+++ b/trunk/cpp/generated/pbrpc/RPC.pb.cc
@@ -0,0 +1,2284 @@
+// 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*\362\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\025\n\021POSIX_E"
+ "RROR_EINTR\020\004\022\023\n\017POSIX_ERROR_EIO\020\005\022\026\n\022POS"
+ "IX_ERROR_EAGAIN\020\013\022\026\n\022POSIX_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\023POSI"
+ "X_ERROR_ENOTDIR\020\024\022\026\n\022POSIX_ERROR_EISDIR\020"
+ "\025\022\026\n\022POSIX_ERROR_EINVAL\020\026\022\031\n\025POSIX_ERROR"
+ "_ENOTEMPTY\020\'\022\027\n\023POSIX_ERROR_ENODATA\020=B3\n"
+ "1org.xtreemfs.foundation.pbrpc.generated"
+ "interfaces", 1530);
+ ::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 4:
+ 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/trunk/cpp/generated/pbrpc/RPC.pb.h b/trunk/cpp/generated/pbrpc/RPC.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d1b0991aeba61c45cd237af5ff789c3a56c8dca
--- /dev/null
+++ b/trunk/cpp/generated/pbrpc/RPC.pb.h
@@ -0,0 +1,1370 @@
+// 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_EINTR = 4,
+ POSIX_ERROR_EIO = 5,
+ POSIX_ERROR_EAGAIN = 11,
+ POSIX_ERROR_EACCES = 13,
+ POSIX_ERROR_EEXIST = 17,
+ POSIX_ERROR_EXDEV = 18,
+ POSIX_ERROR_ENODEV = 19,
+ POSIX_ERROR_ENOTDIR = 20,
+ POSIX_ERROR_EISDIR = 21,
+ POSIX_ERROR_EINVAL = 22,
+ POSIX_ERROR_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/trunk/cpp/generated/xtreemfs/CMakeLists.txt b/trunk/cpp/generated/xtreemfs/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/trunk/cpp/generated/xtreemfs/DIR.pb.cc b/trunk/cpp/generated/xtreemfs/DIR.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bafb18a369feaf200f1990e686bb22bf6af1b8a4
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/xtreemfs/DIR.pb.h b/trunk/cpp/generated/xtreemfs/DIR.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..efa1d828bb086bb183cde15a63f401a9449e3827
--- /dev/null
+++ b/trunk/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/trunk/cpp/generated/xtreemfs/DIRServiceClient.h b/trunk/cpp/generated/xtreemfs/DIRServiceClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..30babf3ef35a5aaa62b1fbbbfd32d8423ffef3d2
--- /dev/null
+++ b/trunk/cpp/generated/xtreemfs/DIRServiceClient.h
@@ -0,0 +1,381 @@
+//automatically generated from DIR.proto at Mon Aug 01 16:12:45 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/trunk/cpp/generated/xtreemfs/GlobalTypes.pb.cc b/trunk/cpp/generated/xtreemfs/GlobalTypes.pb.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f28c16c6c2003cde91d77efcd397bc0f6593a115
--- /dev/null
+++ b/trunk/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
+#include