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
28svn_error_t *
29svn_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
36svn_error_t *
37svn_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
44svn_error_t *
45svn_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
52svn_error_t *
53svn_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
60svn_error_t *
61svn_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
68svn_error_t *
69svn_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
75svn_error_t *
76svn_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
82svn_error_t *
83svn_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
89svn_error_t *
90svn_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
104svn_error_t *
105svn_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
112svn_error_t *
113svn_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
119svn_error_t *
120svn_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
134svn_error_t *
135svn_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
149svn_error_t *
150svn_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
157svn_error_t *
158svn_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
172svn_error_t *
173svn_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
184svn_error_t *
185svn_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
195svn_error_t *
196svn_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
212svn_error_t *
213svn_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
228svn_error_t *
229svn_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}
235