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 #include "svn_ra_svn.h"
  25
  26 #include "private/svn_ra_svn_private.h"
  27
  28 svn_error_t *
  29 svn_ra_svn_write_number(svn_ra_svn_conn_t *conn,
  30                         apr_pool_t *pool,
  31                         apr_uint64_t number)
  32 {
  33   return svn_error_trace(svn_ra_svn__write_number(conn, pool, number));
  34 }
  35
  36 svn_error_t *
  37 svn_ra_svn_write_string(svn_ra_svn_conn_t *conn,
  38                         apr_pool_t *pool,
  39                         const svn_string_t *str)
  40 {
  41   return svn_error_trace(svn_ra_svn__write_string(conn, pool, str));
  42 }
  43
  44 svn_error_t *
  45 svn_ra_svn_write_cstring(svn_ra_svn_conn_t *conn,
  46                          apr_pool_t *pool,
  47                          const char *s)
  48 {
  49   return svn_error_trace(svn_ra_svn__write_cstring(conn, pool, s));
  50 }
  51
  52 svn_error_t *
  53 svn_ra_svn_write_word(svn_ra_svn_conn_t *conn,
  54                       apr_pool_t *pool,
  55                       const char *word)
  56 {
  57   return svn_error_trace(svn_ra_svn__write_word(conn, pool, word));
  58 }
  59
  60 svn_error_t *
  61 svn_ra_svn_write_proplist(svn_ra_svn_conn_t *conn,
  62                           apr_pool_t *pool,
  63                           apr_hash_t *props)
  64 {
  65   return svn_error_trace(svn_ra_svn__write_proplist(conn, pool, props));
  66 }
  67
  68 svn_error_t *
  69 svn_ra_svn_start_list(svn_ra_svn_conn_t *conn,
  70                       apr_pool_t *pool)
  71 {
  72   return svn_error_trace(svn_ra_svn__start_list(conn, pool));
  73 }
  74
  75 svn_error_t *
  76 svn_ra_svn_end_list(svn_ra_svn_conn_t *conn,
  77                     apr_pool_t *pool)
  78 {
  79   return svn_error_trace(svn_ra_svn__end_list(conn, pool));
  80 }
  81
  82 svn_error_t *
  83 svn_ra_svn_flush(svn_ra_svn_conn_t *conn,
  84                  apr_pool_t *pool)
  85 {
  86   return svn_error_trace(svn_ra_svn__flush(conn, pool));
  87 }
  88
  89 svn_error_t *
  90 svn_ra_svn_write_tuple(svn_ra_svn_conn_t *conn,
  91                        apr_pool_t *pool,
  92                        const char *fmt, ...)
  93 {
  94   va_list va;
  95   svn_error_t *err;
  96
  97   va_start(va, fmt);
  98   err = svn_ra_svn__write_tuple(conn, pool, fmt, va);
  99   va_end(va);
 100
 101   return svn_error_trace(err);
 102 }
 103
 104 svn_error_t *
 105 svn_ra_svn_read_item(svn_ra_svn_conn_t *conn,
 106                      apr_pool_t *pool,
 107                      svn_ra_svn_item_t **item)
 108 {
 109   return svn_error_trace(svn_ra_svn__read_item(conn, pool, item));
 110 }
 111
 112 svn_error_t *
 113 svn_ra_svn_skip_leading_garbage(svn_ra_svn_conn_t *conn,
 114                                 apr_pool_t *pool)
 115 {
 116   return svn_error_trace(svn_ra_svn__skip_leading_garbage(conn, pool));
 117 }
 118
 119 svn_error_t *
 120 svn_ra_svn_parse_tuple(const apr_array_header_t *list,
 121                        apr_pool_t *pool,
 122                        const char *fmt, ...)
 123 {
 124   va_list va;
 125   svn_error_t *err;
 126
 127   va_start(va, fmt);
 128   err = svn_ra_svn__parse_tuple(list, pool, fmt, va);
 129   va_end(va);
 130
 131   return svn_error_trace(err);
 132 }
 133
 134 svn_error_t *
 135 svn_ra_svn_read_tuple(svn_ra_svn_conn_t *conn,
 136                       apr_pool_t *pool,
 137                       const char *fmt, ...)
 138 {
 139   va_list va;
 140   svn_error_t *err;
 141
 142   va_start(va, fmt);
 143   err = svn_ra_svn__read_tuple(conn, pool, fmt, va);
 144   va_end(va);
 145
 146   return svn_error_trace(err);
 147 }
 148
 149 svn_error_t *
 150 svn_ra_svn_parse_proplist(const apr_array_header_t *list,
 151                           apr_pool_t *pool,
 152                           apr_hash_t **props)
 153 {
 154   return svn_error_trace(svn_ra_svn__parse_proplist(list, pool, props));
 155 }
 156
 157 svn_error_t *
 158 svn_ra_svn_read_cmd_response(svn_ra_svn_conn_t *conn,
 159                              apr_pool_t *pool,
 160                              const char *fmt, ...)
 161 {
 162   va_list va;
 163   svn_error_t *err;
 164
 165   va_start(va, fmt);
 166   err = svn_ra_svn__read_cmd_response(conn, pool, fmt, va);
 167   va_end(va);
 168
 169   return svn_error_trace(err);
 170 }
 171
 172 svn_error_t *
 173 svn_ra_svn_handle_commands2(svn_ra_svn_conn_t *conn,
 174                             apr_pool_t *pool,
 175                             const svn_ra_svn_cmd_entry_t *commands,
 176                             void *baton,
 177                             svn_boolean_t error_on_disconnect)
 178 {
 179   return svn_error_trace(svn_ra_svn__handle_commands2(conn, pool,
 180                                                       commands, baton,
 181                                                       error_on_disconnect));
 182 }
 183
 184 svn_error_t *
 185 svn_ra_svn_handle_commands(svn_ra_svn_conn_t *conn,
 186                            apr_pool_t *pool,
 187                            const svn_ra_svn_cmd_entry_t *commands,
 188                            void *baton)
 189 {
 190   return svn_error_trace(svn_ra_svn__handle_commands2(conn, pool,
 191                                                       commands, baton,
 192                                                       FALSE));
 193 }
 194
 195 svn_error_t *
 196 svn_ra_svn_write_cmd(svn_ra_svn_conn_t *conn,
 197                      apr_pool_t *pool,
 198                      const char *cmdname,
 199                      const char *fmt, ...)
 200 {
 201   va_list va;
 202   svn_error_t *err;
 203
 204   SVN_ERR(svn_ra_svn__start_list(conn, pool));
 205   SVN_ERR(svn_ra_svn__write_word(conn, pool, cmdname));
 206   va_start(va, fmt);
 207   err = svn_ra_svn__write_tuple(conn, pool, fmt, va);
 208   va_end(va);
 209   return err ? svn_error_trace(err) : svn_ra_svn__end_list(conn, pool);
 210 }
 211
 212 svn_error_t *
 213 svn_ra_svn_write_cmd_response(svn_ra_svn_conn_t *conn,
 214                               apr_pool_t *pool,
 215                               const char *fmt, ...)
 216 {
 217   va_list va;
 218   svn_error_t *err;
 219
 220   va_start(va, fmt);
 221   err = svn_ra_svn__write_cmd_response(conn, pool, fmt, va);
 222   va_end(va);
 223
 224   return svn_error_trace(err);
 225 }
 226
 227
 228 svn_error_t *
 229 svn_ra_svn_write_cmd_failure(svn_ra_svn_conn_t *conn,
 230                              apr_pool_t *pool,
 231                              svn_error_t *err)
 232 {
 233   return svn_error_trace(svn_ra_svn__write_cmd_failure(conn, pool, err));
 234 }