contrib/subversion/subversion/libsvn_fs_fs/temp_serializer.h

   1 /* temp_serializer.h : serialization functions for caching of FSFS structures
   2  *
   3  * ====================================================================
   4  *    Licensed to the Apache Software Foundation (ASF) under one
   5  *    or more contributor license agreements.  See the NOTICE file
   6  *    distributed with this work for additional information
   7  *    regarding copyright ownership.  The ASF licenses this file
   8  *    to you under the Apache License, Version 2.0 (the
   9  *    "License"); you may not use this file except in compliance
  10  *    with the License.  You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  *    Unless required by applicable law or agreed to in writing,
  15  *    software distributed under the License is distributed on an
  16  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  *    KIND, either express or implied.  See the License for the
  18  *    specific language governing permissions and limitations
  19  *    under the License.
  20  * ====================================================================
  21  */
  22
  23 #ifndef SVN_LIBSVN_FS__TEMP_SERIALIZER_H
  24 #define SVN_LIBSVN_FS__TEMP_SERIALIZER_H
  25
  26 #include "fs.h"
  27
  28 /**
  29  * Prepend the @a number to the @a string in a space efficient way such that
  30  * no other (number,string) combination can produce the same result.
  31  * Allocate temporaries as well as the result from @a pool.
  32  */
  33 const char*
  34 svn_fs_fs__combine_number_and_string(apr_int64_t number,
  35                                      const char *string,
  36                                      apr_pool_t *pool);
  37
  38 /**
  39  * Serialize a @a noderev_p within the serialization @a context.
  40  */
  41 void
  42 svn_fs_fs__noderev_serialize(struct svn_temp_serializer__context_t *context,
  43                              node_revision_t * const *noderev_p);
  44
  45 /**
  46  * Deserialize a @a noderev_p within the @a buffer.
  47  */
  48 void
  49 svn_fs_fs__noderev_deserialize(void *buffer,
  50                                node_revision_t **noderev_p);
  51
  52
  53 /**
  54  * Adds position information to the the raw window data in WINDOW.
  55  */
  56 typedef struct
  57 {
  58   /* the (unprocessed) txdelta window byte sequence cached / to be cached */
  59   svn_string_t window;
  60
  61   /* the offset within the representation right after reading the window */
  62   apr_off_t end_offset;
  63 } svn_fs_fs__raw_cached_window_t;
  64
  65 /**
  66  * Implements #svn_cache__serialize_func_t for
  67  * #svn_fs_fs__raw_cached_window_t.
  68  */
  69 svn_error_t *
  70 svn_fs_fs__serialize_raw_window(void **buffer,
  71                                 apr_size_t *buffer_size,
  72                                 void *item,
  73                                 apr_pool_t *pool);
  74
  75 /**
  76  * Implements #svn_cache__deserialize_func_t for
  77  * #svn_fs_fs__raw_cached_window_t.
  78  */
  79 svn_error_t *
  80 svn_fs_fs__deserialize_raw_window(void **item,
  81                                   void *buffer,
  82                                   apr_size_t buffer_size,
  83                                   apr_pool_t *pool);
  84
  85 /**
  86  * #svn_txdelta_window_t is not sufficient for caching the data it
  87  * represents because data read process needs auxiliary information.
  88  */
  89 typedef struct
  90 {
  91   /* the txdelta window information cached / to be cached */
  92   svn_txdelta_window_t *window;
  93
  94   /* the revision file read pointer position right after reading the window */
  95   apr_off_t end_offset;
  96 } svn_fs_fs__txdelta_cached_window_t;
  97
  98 /**
  99  * Implements #svn_cache__serialize_func_t for
 100  * #svn_fs_fs__txdelta_cached_window_t.
 101  */
 102 svn_error_t *
 103 svn_fs_fs__serialize_txdelta_window(void **buffer,
 104                                     apr_size_t *buffer_size,
 105                                     void *item,
 106                                     apr_pool_t *pool);
 107
 108 /**
 109  * Implements #svn_cache__deserialize_func_t for
 110  * #svn_fs_fs__txdelta_cached_window_t.
 111  */
 112 svn_error_t *
 113 svn_fs_fs__deserialize_txdelta_window(void **item,
 114                                       void *buffer,
 115                                       apr_size_t buffer_size,
 116                                       apr_pool_t *pool);
 117
 118 /**
 119  * Implements #svn_cache__serialize_func_t for a manifest
 120  * (@a in is an #apr_array_header_t of apr_off_t elements).
 121  */
 122 svn_error_t *
 123 svn_fs_fs__serialize_manifest(void **data,
 124                               apr_size_t *data_len,
 125                               void *in,
 126                               apr_pool_t *pool);
 127
 128 /**
 129  * Implements #svn_cache__deserialize_func_t for a manifest
 130  * (@a *out is an #apr_array_header_t of apr_off_t elements).
 131  */
 132 svn_error_t *
 133 svn_fs_fs__deserialize_manifest(void **out,
 134                                 void *data,
 135                                 apr_size_t data_len,
 136                                 apr_pool_t *pool);
 137
 138 /**
 139  * Implements #svn_cache__serialize_func_t for a properties hash
 140  * (@a in is an #apr_hash_t of svn_string_t elements, keyed by const char*).
 141  */
 142 svn_error_t *
 143 svn_fs_fs__serialize_properties(void **data,
 144                                 apr_size_t *data_len,
 145                                 void *in,
 146                                 apr_pool_t *pool);
 147
 148 /**
 149  * Implements #svn_cache__deserialize_func_t for a properties hash
 150  * (@a *out is an #apr_hash_t of svn_string_t elements, keyed by const char*).
 151  */
 152 svn_error_t *
 153 svn_fs_fs__deserialize_properties(void **out,
 154                                   void *data,
 155                                   apr_size_t data_len,
 156                                   apr_pool_t *pool);
 157
 158 /**
 159  * Implements #svn_cache__serialize_func_t for #svn_fs_id_t
 160  */
 161 svn_error_t *
 162 svn_fs_fs__serialize_id(void **data,
 163                         apr_size_t *data_len,
 164                         void *in,
 165                         apr_pool_t *pool);
 166
 167 /**
 168  * Implements #svn_cache__deserialize_func_t for #svn_fs_id_t
 169  */
 170 svn_error_t *
 171 svn_fs_fs__deserialize_id(void **out,
 172                           void *data,
 173                           apr_size_t data_len,
 174                           apr_pool_t *pool);
 175
 176 /**
 177  * Implements #svn_cache__serialize_func_t for #node_revision_t
 178  */
 179 svn_error_t *
 180 svn_fs_fs__serialize_node_revision(void **buffer,
 181                                    apr_size_t *buffer_size,
 182                                    void *item,
 183                                    apr_pool_t *pool);
 184
 185 /**
 186  * Implements #svn_cache__deserialize_func_t for #node_revision_t
 187  */
 188 svn_error_t *
 189 svn_fs_fs__deserialize_node_revision(void **item,
 190                                      void *buffer,
 191                                      apr_size_t buffer_size,
 192                                      apr_pool_t *pool);
 193
 194 /**
 195  * Implements #svn_cache__serialize_func_t for a directory contents array
 196  */
 197 svn_error_t *
 198 svn_fs_fs__serialize_dir_entries(void **data,
 199                                  apr_size_t *data_len,
 200                                  void *in,
 201                                  apr_pool_t *pool);
 202
 203 /**
 204  * Implements #svn_cache__deserialize_func_t for a directory contents array
 205  */
 206 svn_error_t *
 207 svn_fs_fs__deserialize_dir_entries(void **out,
 208                                    void *data,
 209                                    apr_size_t data_len,
 210                                    apr_pool_t *pool);
 211
 212 /**
 213  * Implements #svn_cache__partial_getter_func_t.  Set (apr_off_t) @a *out
 214  * to the element indexed by (apr_int64_t) @a *baton within the
 215  * serialized manifest array @a data and @a data_len. */
 216 svn_error_t *
 217 svn_fs_fs__get_sharded_offset(void **out,
 218                               const void *data,
 219                               apr_size_t data_len,
 220                               void *baton,
 221                               apr_pool_t *pool);
 222
 223 /**
 224  * Implements #svn_cache__partial_getter_func_t for a single
 225  * #svn_fs_dirent_t within a serialized directory contents hash,
 226  * identified by its name (const char @a *baton).
 227  */
 228 svn_error_t *
 229 svn_fs_fs__extract_dir_entry(void **out,
 230                              const void *data,
 231                              apr_size_t data_len,
 232                              void *baton,
 233                              apr_pool_t *pool);
 234
 235 /**
 236  * Describes the change to be done to a directory: Set the entry
 237  * identify by @a name to the value @a new_entry. If the latter is
 238  * @c NULL, the entry shall be removed if it exists. Otherwise it
 239  * will be replaced or automatically added, respectively.
 240  */
 241 typedef struct replace_baton_t
 242 {
 243   /** name of the directory entry to modify */
 244   const char *name;
 245
 246   /** directory entry to insert instead */
 247   svn_fs_dirent_t *new_entry;
 248 } replace_baton_t;
 249
 250 /**
 251  * Implements #svn_cache__partial_setter_func_t for a single
 252  * #svn_fs_dirent_t within a serialized directory contents hash,
 253  * identified by its name in the #replace_baton_t in @a baton.
 254  */
 255 svn_error_t *
 256 svn_fs_fs__replace_dir_entry(void **data,
 257                              apr_size_t *data_len,
 258                              void *baton,
 259                              apr_pool_t *pool);
 260
 261 /**
 262  * Implements #svn_cache__serialize_func_t for a #svn_fs_fs__rep_header_t.
 263  */
 264 svn_error_t *
 265 svn_fs_fs__serialize_rep_header(void **data,
 266                                 apr_size_t *data_len,
 267                                 void *in,
 268                                 apr_pool_t *pool);
 269
 270 /**
 271  * Implements #svn_cache__deserialize_func_t for a #svn_fs_fs__rep_header_t.
 272  */
 273 svn_error_t *
 274 svn_fs_fs__deserialize_rep_header(void **out,
 275                                   void *data,
 276                                   apr_size_t data_len,
 277                                   apr_pool_t *pool);
 278
 279 /**
 280  * Implements #svn_cache__serialize_func_t for an #apr_array_header_t of
 281  * #change_t *.
 282  */
 283 svn_error_t *
 284 svn_fs_fs__serialize_changes(void **data,
 285                              apr_size_t *data_len,
 286                              void *in,
 287                              apr_pool_t *pool);
 288
 289 /**
 290  * Implements #svn_cache__deserialize_func_t for an #apr_array_header_t of
 291  * #change_t *.
 292  */
 293 svn_error_t *
 294 svn_fs_fs__deserialize_changes(void **out,
 295                                void *data,
 296                                apr_size_t data_len,
 297                                apr_pool_t *pool);
 298
 299 /**
 300  * Implements #svn_cache__serialize_func_t for #svn_mergeinfo_t objects.
 301  */
 302 svn_error_t *
 303 svn_fs_fs__serialize_mergeinfo(void **data,
 304                                apr_size_t *data_len,
 305                                void *in,
 306                                apr_pool_t *pool);
 307
 308 /**
 309  * Implements #svn_cache__deserialize_func_t for #svn_mergeinfo_t objects.
 310  */
 311 svn_error_t *
 312 svn_fs_fs__deserialize_mergeinfo(void **out,
 313                                  void *data,
 314                                  apr_size_t data_len,
 315                                  apr_pool_t *pool);
 316
 317 #endif