contrib/subversion/subversion/libsvn_ra_svn/deprecated.c

   1 /*
   2  * deprecated.c :  Public, deprecated wrappers to our private ra_svn API
   3  *
   4  * ====================================================================
   5  *    Licensed to the Apache Software Foundation (ASF) under one
   6  *    or more contributor license agreements.  See the NOTICE file
   7  *    distributed with this work for additional information
   8  *    regarding copyright ownership.  The ASF licenses this file
   9  *    to you under the Apache License, Version 2.0 (the
  10  *    "License"); you may not use this file except in compliance
  11  *    with the License.  You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  *    Unless required by applicable law or agreed to in writing,
  16  *    software distributed under the License is distributed on an
  17  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  18  *    KIND, either express or implied.  See the License for the
  19  *    specific language governing permissions and limitations
  20  *    under the License.
  21  * ====================================================================
  22  */
  23
  24 /* We define this here to remove any further warnings about the usage of
  25    deprecated functions in this file. */
  26 #define SVN_DEPRECATED
  27
  28 #include "svn_ra_svn.h"
  29
  30 #include "private/svn_ra_svn_private.h"
  31
  32 svn_error_t *
  33 svn_ra_svn_write_number(svn_ra_svn_conn_t *conn,
  34                         apr_pool_t *pool,
  35                         apr_uint64_t number)
  36 {
  37   return svn_error_trace(svn_ra_svn__write_number(conn, pool, number));
  38 }
  39
  40 svn_error_t *
  41 svn_ra_svn_write_string(svn_ra_svn_conn_t *conn,
  42                         apr_pool_t *pool,
  43                         const svn_string_t *str)
  44 {
  45   return svn_error_trace(svn_ra_svn__write_string(conn, pool, str));
  46 }
  47
  48 svn_error_t *
  49 svn_ra_svn_write_cstring(svn_ra_svn_conn_t *conn,
  50                          apr_pool_t *pool,
  51                          const char *s)
  52 {
  53   return svn_error_trace(svn_ra_svn__write_cstring(conn, pool, s));
  54 }
  55
  56 svn_error_t *
  57 svn_ra_svn_write_word(svn_ra_svn_conn_t *conn,
  58                       apr_pool_t *pool,
  59                       const char *word)
  60 {
  61   return svn_error_trace(svn_ra_svn__write_word(conn, pool, word));
  62 }
  63
  64 svn_error_t *
  65 svn_ra_svn_write_proplist(svn_ra_svn_conn_t *conn,
  66                           apr_pool_t *pool,
  67                           apr_hash_t *props)
  68 {
  69   return svn_error_trace(svn_ra_svn__write_proplist(conn, pool, props));
  70 }
  71
  72 svn_error_t *
  73 svn_ra_svn_start_list(svn_ra_svn_conn_t *conn,
  74                       apr_pool_t *pool)
  75 {
  76   return svn_error_trace(svn_ra_svn__start_list(conn, pool));
  77 }
  78
  79 svn_error_t *
  80 svn_ra_svn_end_list(svn_ra_svn_conn_t *conn,
  81                     apr_pool_t *pool)
  82 {
  83   return svn_error_trace(svn_ra_svn__end_list(conn, pool));
  84 }
  85
  86 svn_error_t *
  87 svn_ra_svn_flush(svn_ra_svn_conn_t *conn,
  88                  apr_pool_t *pool)
  89 {
  90   return svn_error_trace(svn_ra_svn__flush(conn, pool));
  91 }
  92
  93 svn_error_t *
  94 svn_ra_svn_write_tuple(svn_ra_svn_conn_t *conn,
  95                        apr_pool_t *pool,
  96                        const char *fmt, ...)
  97 {
  98   va_list va;
  99   svn_error_t *err;
 100
 101   va_start(va, fmt);
 102   err = svn_ra_svn__write_tuple(conn, pool, fmt, va);
 103   va_end(va);
 104
 105   return svn_error_trace(err);
 106 }
 107
 108 svn_error_t *
 109 svn_ra_svn_read_item(svn_ra_svn_conn_t *conn,
 110                      apr_pool_t *pool,
 111                      svn_ra_svn_item_t **item)
 112 {
 113   return svn_error_trace(svn_ra_svn__read_item(conn, pool, item));
 114 }
 115
 116 svn_error_t *
 117 svn_ra_svn_skip_leading_garbage(svn_ra_svn_conn_t *conn,
 118                                 apr_pool_t *pool)
 119 {
 120   return svn_error_trace(svn_ra_svn__skip_leading_garbage(conn, pool));
 121 }
 122
 123 svn_error_t *
 124 svn_ra_svn_parse_tuple(const apr_array_header_t *list,
 125                        apr_pool_t *pool,
 126                        const char *fmt, ...)
 127 {
 128   va_list va;
 129   svn_error_t *err;
 130
 131   va_start(va, fmt);
 132   err = svn_ra_svn__parse_tuple(list, pool, fmt, va);
 133   va_end(va);
 134
 135   return svn_error_trace(err);
 136 }
 137
 138 svn_error_t *
 139 svn_ra_svn_read_tuple(svn_ra_svn_conn_t *conn,
 140                       apr_pool_t *pool,
 141                       const char *fmt, ...)
 142 {
 143   va_list va;
 144   svn_error_t *err;
 145
 146   va_start(va, fmt);
 147   err = svn_ra_svn__read_tuple(conn, pool, fmt, va);
 148   va_end(va);
 149
 150   return svn_error_trace(err);
 151 }
 152
 153 svn_error_t *
 154 svn_ra_svn_parse_proplist(const apr_array_header_t *list,
 155                           apr_pool_t *pool,
 156                           apr_hash_t **props)
 157 {
 158   return svn_error_trace(svn_ra_svn__parse_proplist(list, pool, props));
 159 }
 160
 161 svn_error_t *
 162 svn_ra_svn_read_cmd_response(svn_ra_svn_conn_t *conn,
 163                              apr_pool_t *pool,
 164                              const char *fmt, ...)
 165 {
 166   va_list va;
 167   svn_error_t *err;
 168
 169   va_start(va, fmt);
 170   err = svn_ra_svn__read_cmd_response(conn, pool, fmt, va);
 171   va_end(va);
 172
 173   return svn_error_trace(err);
 174 }
 175
 176 svn_error_t *
 177 svn_ra_svn_handle_commands2(svn_ra_svn_conn_t *conn,
 178                             apr_pool_t *pool,
 179                             const svn_ra_svn_cmd_entry_t *commands,
 180                             void *baton,
 181                             svn_boolean_t error_on_disconnect)
 182 {
 183   return svn_error_trace(svn_ra_svn__handle_commands2(conn, pool,
 184                                                       commands, baton,
 185                                                       error_on_disconnect));
 186 }
 187
 188 svn_error_t *
 189 svn_ra_svn_handle_commands(svn_ra_svn_conn_t *conn,
 190                            apr_pool_t *pool,
 191                            const svn_ra_svn_cmd_entry_t *commands,
 192                            void *baton)
 193 {
 194   return svn_error_trace(svn_ra_svn__handle_commands2(conn, pool,
 195                                                       commands, baton,
 196                                                       FALSE));
 197 }
 198
 199 svn_error_t *
 200 svn_ra_svn_write_cmd(svn_ra_svn_conn_t *conn,
 201                      apr_pool_t *pool,
 202                      const char *cmdname,
 203                      const char *fmt, ...)
 204 {
 205   va_list va;
 206   svn_error_t *err;
 207
 208   SVN_ERR(svn_ra_svn__start_list(conn, pool));
 209   SVN_ERR(svn_ra_svn__write_word(conn, pool, cmdname));
 210   va_start(va, fmt);
 211   err = svn_ra_svn__write_tuple(conn, pool, fmt, va);
 212   va_end(va);
 213   return err ? svn_error_trace(err) : svn_ra_svn__end_list(conn, pool);
 214 }
 215
 216 svn_error_t *
 217 svn_ra_svn_write_cmd_response(svn_ra_svn_conn_t *conn,
 218                               apr_pool_t *pool,
 219                               const char *fmt, ...)
 220 {
 221   va_list va;
 222   svn_error_t *err;
 223
 224   va_start(va, fmt);
 225   err = svn_ra_svn__write_cmd_response(conn, pool, fmt, va);
 226   va_end(va);
 227
 228   return svn_error_trace(err);
 229 }
 230
 231
 232 svn_error_t *
 233 svn_ra_svn_write_cmd_failure(svn_ra_svn_conn_t *conn,
 234                              apr_pool_t *pool,
 235                              svn_error_t *err)
 236 {
 237   return svn_error_trace(svn_ra_svn__write_cmd_failure(conn, pool, err));
 238 }
 239
 240 /* From marshal.c */
 241 svn_ra_svn_conn_t *
 242 svn_ra_svn_create_conn3(apr_socket_t *sock,
 243                         apr_file_t *in_file,
 244                         apr_file_t *out_file,
 245                         int compression_level,
 246                         apr_size_t zero_copy_limit,
 247                         apr_size_t error_check_interval,
 248                         apr_pool_t *pool)
 249 {
 250   svn_stream_t *in_stream = NULL;
 251   svn_stream_t *out_stream = NULL;
 252
 253   if (in_file)
 254     in_stream = svn_stream_from_aprfile2(in_file, FALSE, pool);
 255   if (out_file)
 256     out_stream = svn_stream_from_aprfile2(out_file, FALSE, pool);
 257
 258   return svn_ra_svn_create_conn4(sock, in_stream, out_stream,
 259                                  compression_level, zero_copy_limit,
 260                                  error_check_interval, pool);
 261 }
 262
 263 svn_ra_svn_conn_t *
 264 svn_ra_svn_create_conn2(apr_socket_t *sock,
 265                         apr_file_t *in_file,
 266                         apr_file_t *out_file,
 267                         int compression_level,
 268                         apr_pool_t *pool)
 269 {
 270   return svn_ra_svn_create_conn3(sock, in_file, out_file,
 271                                  compression_level, 0, 0, pool);
 272 }
 273
 274 /* backward-compatible implementation using the default compression level */
 275 svn_ra_svn_conn_t *
 276 svn_ra_svn_create_conn(apr_socket_t *sock,
 277                        apr_file_t *in_file,
 278                        apr_file_t *out_file,
 279                        apr_pool_t *pool)
 280 {
 281   return svn_ra_svn_create_conn3(sock, in_file, out_file,
 282                                  SVN_DELTA_COMPRESSION_LEVEL_DEFAULT, 0, 0,
 283                                  pool);
 284 }