| /* |
| * svn_subr_private.h : private definitions from libsvn_subr |
| * |
| * ==================================================================== |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * ==================================================================== |
| */ |
| |
| #ifndef SVN_SUBR_PRIVATE_H |
| #define SVN_SUBR_PRIVATE_H |
| |
| #include "svn_types.h" |
| #include "svn_io.h" |
| #include "svn_config.h" |
| |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif /* __cplusplus */ |
| |
| |
| /** Spill-to-file Buffers |
| * |
| * @defgroup svn_spillbuf_t Spill-to-file Buffers |
| * @{ |
| */ |
| |
| /** A buffer that collects blocks of content, possibly using a file. |
| * |
| * The spill-buffer is created with two basic parameters: the size of the |
| * blocks that will be written into the spill-buffer ("blocksize"), and |
| * the (approximate) maximum size that will be allowed in memory ("maxsize"). |
| * Once the maxsize is reached, newly written content will be "spilled" |
| * into a temporary file. |
| * |
| * When writing, content will be buffered into memory unless a given write |
| * will cause the amount of in-memory content to exceed the specified |
| * maxsize. At that point, the file is created, and the content will be |
| * written to that file. |
| * |
| * To read information back out of a spill buffer, there are two approaches |
| * available to the application: |
| * |
| * *) reading blocks using svn_spillbuf_read() (a "pull" model) |
| * *) having blocks passed to a callback via svn_spillbuf_process() |
| * (a "push" model to your application) |
| * |
| * In both cases, the spill-buffer will provide you with a block of N bytes |
| * that you must fully consume before asking for more data. The callback |
| * style provides for a "stop" parameter to temporarily pause the reading |
| * until another read is desired. The two styles of reading may be mixed, |
| * as the caller desires. Generally, N will be the blocksize, and will be |
| * less when the end of the content is reached. |
| * |
| * For a more stream-oriented style of reading, where the caller specifies |
| * the number of bytes to read into a caller-provided buffer, please see |
| * svn_spillbuf_reader_t. That overlaid type will cause more memory copies |
| * to be performed (whereas the bare spill-buffer type hands you a buffer |
| * to consume). |
| * |
| * Writes may be interleaved with reading, and content will be returned |
| * in a FIFO manner. Thus, if content has been placed into the spill-buffer |
| * you will always read the earliest-written data, and any newly-written |
| * content will be appended to the buffer. |
| * |
| * Note: the file is created in the same pool where the spill-buffer was |
| * created. If the content is completely read from that file, it will be |
| * closed and deleted. Should writing further content cause another spill |
| * file to be created, that will increase the size of the pool. There is |
| * no bound on the amount of file-related resources that may be consumed |
| * from the pool. It is entirely related to the read/write pattern and |
| * whether spill files are repeatedly created. |
| */ |
| typedef struct svn_spillbuf_t svn_spillbuf_t; |
| |
| |
| /* Create a spill buffer. */ |
| svn_spillbuf_t * |
| svn_spillbuf__create(apr_size_t blocksize, |
| apr_size_t maxsize, |
| apr_pool_t *result_pool); |
| |
| /* Create a spill buffer, with extra parameters. */ |
| svn_spillbuf_t * |
| svn_spillbuf__create_extended(apr_size_t blocksize, |
| apr_size_t maxsize, |
| svn_boolean_t delete_on_close, |
| svn_boolean_t spill_all_contents, |
| const char* dirpath, |
| apr_pool_t *result_pool); |
| |
| /* Determine how much content is stored in the spill buffer. */ |
| svn_filesize_t |
| svn_spillbuf__get_size(const svn_spillbuf_t *buf); |
| |
| /* Determine how much content the spill buffer is caching in memory. */ |
| svn_filesize_t |
| svn_spillbuf__get_memory_size(const svn_spillbuf_t *buf); |
| |
| /* Retrieve the name of the spill file. The returned value will be |
| NULL if the file has not been created yet. */ |
| const char * |
| svn_spillbuf__get_filename(const svn_spillbuf_t *buf); |
| |
| /* Retrieve the handle of the spill file. The returned value will be |
| NULL if the file has not been created yet. */ |
| apr_file_t * |
| svn_spillbuf__get_file(const svn_spillbuf_t *buf); |
| |
| /* Write some data into the spill buffer. */ |
| svn_error_t * |
| svn_spillbuf__write(svn_spillbuf_t *buf, |
| const char *data, |
| apr_size_t len, |
| apr_pool_t *scratch_pool); |
| |
| |
| /* Read a block of memory from the spill buffer. @a *data will be set to |
| NULL if no content remains. Otherwise, @a data and @a len will point to |
| data that must be fully-consumed by the caller. This data will remain |
| valid until another call to svn_spillbuf__write(), svn_spillbuf__read(), |
| or svn_spillbuf__process(), or if the spill buffer's pool is cleared. */ |
| svn_error_t * |
| svn_spillbuf__read(const char **data, |
| apr_size_t *len, |
| svn_spillbuf_t *buf, |
| apr_pool_t *scratch_pool); |
| |
| |
| /* Callback for reading content out of the spill buffer. Set @a stop if |
| you want to stop the processing (and will call svn_spillbuf__process |
| again, at a later time). */ |
| typedef svn_error_t * (*svn_spillbuf_read_t)(svn_boolean_t *stop, |
| void *baton, |
| const char *data, |
| apr_size_t len, |
| apr_pool_t *scratch_pool); |
| |
| |
| /* Process the content stored in the spill buffer. @a exhausted will be |
| set to TRUE if all of the content is processed by @a read_func. This |
| function may return early if the callback returns TRUE for its 'stop' |
| parameter. */ |
| svn_error_t * |
| svn_spillbuf__process(svn_boolean_t *exhausted, |
| svn_spillbuf_t *buf, |
| svn_spillbuf_read_t read_func, |
| void *read_baton, |
| apr_pool_t *scratch_pool); |
| |
| |
| /** Classic stream reading layer on top of spill-buffers. |
| * |
| * This type layers upon a spill-buffer to enable a caller to read a |
| * specified number of bytes into the caller's provided buffer. This |
| * implies more memory copies than the standard spill-buffer reading |
| * interface, but is sometimes required by spill-buffer users. |
| */ |
| typedef struct svn_spillbuf_reader_t svn_spillbuf_reader_t; |
| |
| |
| /* Create a spill-buffer and a reader for it, using the same arguments as |
| svn_spillbuf__create(). */ |
| svn_spillbuf_reader_t * |
| svn_spillbuf__reader_create(apr_size_t blocksize, |
| apr_size_t maxsize, |
| apr_pool_t *result_pool); |
| |
| /* Read @a len bytes from @a reader into @a data. The number of bytes |
| actually read is stored in @a amt. If the content is exhausted, then |
| @a amt is set to zero. It will always be non-zero if the spill-buffer |
| contains content. |
| |
| If @a len is zero, then SVN_ERR_INCORRECT_PARAMS is returned. */ |
| svn_error_t * |
| svn_spillbuf__reader_read(apr_size_t *amt, |
| svn_spillbuf_reader_t *reader, |
| char *data, |
| apr_size_t len, |
| apr_pool_t *scratch_pool); |
| |
| |
| /* Read a single character from @a reader, and place it in @a c. If there |
| is no content in the spill-buffer, then SVN_ERR_STREAM_UNEXPECTED_EOF |
| is returned. */ |
| svn_error_t * |
| svn_spillbuf__reader_getc(char *c, |
| svn_spillbuf_reader_t *reader, |
| apr_pool_t *scratch_pool); |
| |
| |
| /* Write @a len bytes from @a data into the spill-buffer in @a reader. */ |
| svn_error_t * |
| svn_spillbuf__reader_write(svn_spillbuf_reader_t *reader, |
| const char *data, |
| apr_size_t len, |
| apr_pool_t *scratch_pool); |
| |
| |
| /* Return a stream built on top of a spillbuf. |
| |
| This stream can be used for reading and writing, but implements the |
| same basic semantics of a spillbuf for the underlying storage. */ |
| svn_stream_t * |
| svn_stream__from_spillbuf(svn_spillbuf_t *buf, |
| apr_pool_t *result_pool); |
| |
| /** @} */ |
| |
| /*----------------------------------------------------*/ |
| |
| /** |
| * @defgroup svn_checksum_private Checksumming helper APIs |
| * @{ |
| */ |
| |
| /** |
| * Internal function for creating a MD5 checksum from a binary digest. |
| * |
| * @since New in 1.8 |
| */ |
| svn_checksum_t * |
| svn_checksum__from_digest_md5(const unsigned char *digest, |
| apr_pool_t *result_pool); |
| |
| /** |
| * Internal function for creating a SHA1 checksum from a binary |
| * digest. |
| * |
| * @since New in 1.8 |
| */ |
| svn_checksum_t * |
| svn_checksum__from_digest_sha1(const unsigned char *digest, |
| apr_pool_t *result_pool); |
| |
| /** |
| * Internal function for creating a 32 bit FNV-1a checksum from a binary |
| * digest. |
| * |
| * @since New in 1.9 |
| */ |
| svn_checksum_t * |
| svn_checksum__from_digest_fnv1a_32(const unsigned char *digest, |
| apr_pool_t *result_pool); |
| |
| /** |
| * Internal function for creating a modified 32 bit FNV-1a checksum from |
| * a binary digest. |
| * |
| * @since New in 1.9 |
| */ |
| svn_checksum_t * |
| svn_checksum__from_digest_fnv1a_32x4(const unsigned char *digest, |
| apr_pool_t *result_pool); |
| |
| |
| /** |
| * Return a stream that calculates a checksum of type @a kind over all |
| * data written to the @a inner_stream. When the returned stream gets |
| * closed, write the checksum to @a *checksum. |
| * Allocate the result in @a pool. |
| * |
| * @note The stream returned only supports #svn_stream_write and |
| * #svn_stream_close. |
| */ |
| svn_stream_t * |
| svn_checksum__wrap_write_stream(svn_checksum_t **checksum, |
| svn_stream_t *inner_stream, |
| svn_checksum_kind_t kind, |
| apr_pool_t *pool); |
| |
| /** |
| * Return a stream that calculates a 32 bit modified FNV-1a checksum |
| * over all data written to the @a inner_stream and writes the digest |
| * to @a *digest when the returned stream gets closed. |
| * Allocate the stream in @a pool. |
| */ |
| svn_stream_t * |
| svn_checksum__wrap_write_stream_fnv1a_32x4(apr_uint32_t *digest, |
| svn_stream_t *inner_stream, |
| apr_pool_t *pool); |
| |
| /** |
| * Return a 32 bit FNV-1a checksum for the first @a len bytes in @a input. |
| * |
| * @since New in 1.9 |
| */ |
| apr_uint32_t |
| svn__fnv1a_32(const void *input, apr_size_t len); |
| |
| /** |
| * Return a 32 bit modified FNV-1a checksum for the first @a len bytes in |
| * @a input. |
| * |
| * @note This is a proprietary checksumming algorithm based FNV-1a with |
| * approximately the same strength. It is up to 4 times faster |
| * than plain FNV-1a for longer data blocks. |
| * |
| * @since New in 1.9 |
| */ |
| apr_uint32_t |
| svn__fnv1a_32x4(const void *input, apr_size_t len); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_hash_support Hash table serialization support |
| * @{ |
| */ |
| |
| /*----------------------------------------------------*/ |
| |
| /** |
| * @defgroup svn_hash_misc Miscellaneous hash APIs |
| * @{ |
| */ |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_hash_getters Specialized getter APIs for hashes |
| * @{ |
| */ |
| |
| /** Find the value of a @a key in @a hash, return the value. |
| * |
| * If @a hash is @c NULL or if the @a key cannot be found, the |
| * @a default_value will be returned. |
| * |
| * @since New in 1.7. |
| */ |
| const char * |
| svn_hash__get_cstring(apr_hash_t *hash, |
| const char *key, |
| const char *default_value); |
| |
| /** Like svn_hash_get_cstring(), but for boolean values. |
| * |
| * Parses the value as a boolean value. The recognized representations |
| * are 'TRUE'/'FALSE', 'yes'/'no', 'on'/'off', '1'/'0'; case does not |
| * matter. |
| * |
| * @since New in 1.7. |
| */ |
| svn_boolean_t |
| svn_hash__get_bool(apr_hash_t *hash, |
| const char *key, |
| svn_boolean_t default_value); |
| |
| /** @} */ |
| |
| /** |
| * @defgroup svn_hash_create Create optimized APR hash tables |
| * @{ |
| */ |
| |
| /** Returns a hash table, allocated in @a pool, with the same ordering of |
| * elements as APR 1.4.5 or earlier (using apr_hashfunc_default) but uses |
| * a faster hash function implementation. |
| * |
| * @since New in 1.8. |
| */ |
| apr_hash_t * |
| svn_hash__make(apr_pool_t *pool); |
| |
| /** @} */ |
| |
| /** |
| * @defgroup svn_hash_read Reading serialized hash tables |
| * @{ |
| */ |
| |
| /** Struct that represents a key value pair read from a serialized hash |
| * representation. There are special cases that can also be represented: |
| * a NULL @a key signifies the end of the hash, a NULL @a val for non- |
| * NULL keys is only possible in incremental mode describes a deletion. |
| * |
| * @since New in 1.9. |
| */ |
| typedef struct svn_hash__entry_t |
| { |
| /** 0-terminated Key. NULL if this contains no data at all because we |
| * encountered the end of the hash. */ |
| char *key; |
| |
| /** Length of @a key. Must be 0 if @a key is NULL. */ |
| apr_size_t keylen; |
| |
| /** 0-terminated value stored with the key. If this is NULL for a |
| * non-NULL @a key, then this means that the key shall be removed from |
| * the hash (only used in incremental mode). Must be NULL if @a key is |
| * NULL. */ |
| char *val; |
| |
| /** Length of @a val. Must be 0 if @a val is NULL. */ |
| apr_size_t vallen; |
| } svn_hash__entry_t; |
| |
| /** Reads a single key-value pair from @a stream and returns it in the |
| * caller-provided @a *entry (members don't need to be pre-initialized). |
| * @a pool is used to allocate members of @a *entry and for tempoaries. |
| * |
| * @see #svn_hash_read2 for more details. |
| * |
| * @since New in 1.9. |
| */ |
| svn_error_t * |
| svn_hash__read_entry(svn_hash__entry_t *entry, |
| svn_stream_t *stream, |
| const char *terminator, |
| svn_boolean_t incremental, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| /** @} */ |
| |
| |
| /** Apply the changes described by @a prop_changes to @a original_props and |
| * return the result. The inverse of svn_prop_diffs(). |
| * |
| * Allocate the resulting hash from @a pool, but allocate its keys and |
| * values from @a pool and/or by reference to the storage of the inputs. |
| * |
| * Note: some other APIs use an array of pointers to svn_prop_t. |
| * |
| * @since New in 1.8. |
| */ |
| apr_hash_t * |
| svn_prop__patch(const apr_hash_t *original_props, |
| const apr_array_header_t *prop_changes, |
| apr_pool_t *pool); |
| |
| |
| /** |
| * @defgroup svn_version Version number dotted triplet parsing |
| * @{ |
| */ |
| |
| /* Set @a *version to a version structure parsed from the version |
| * string representation in @a version_string. Return |
| * @c SVN_ERR_MALFORMED_VERSION_STRING if the string fails to parse |
| * cleanly. |
| * |
| * @since New in 1.8. |
| */ |
| svn_error_t * |
| svn_version__parse_version_string(svn_version_t **version, |
| const char *version_string, |
| apr_pool_t *result_pool); |
| |
| /* Return true iff @a version represents a version number of at least |
| * the level represented by @a major, @a minor, and @a patch. |
| * |
| * @since New in 1.8. |
| */ |
| svn_boolean_t |
| svn_version__at_least(const svn_version_t *version, |
| int major, |
| int minor, |
| int patch); |
| |
| /** @} */ |
| |
| /** |
| * @defgroup svn_compress Data (de-)compression API |
| * @{ |
| */ |
| |
| /* This is at least as big as the largest size of an integer that |
| svn__encode_uint() can generate; it is sufficient for creating buffers |
| for it to write into. This assumes that integers are at most 64 bits, |
| and so 10 bytes (with 7 bits of information each) are sufficient to |
| represent them. */ |
| #define SVN__MAX_ENCODED_UINT_LEN 10 |
| |
| /* Compression method parameters for svn__encode_uint. */ |
| |
| /* No compression (but a length prefix will still be added to the buffer) */ |
| #define SVN__COMPRESSION_NONE 0 |
| |
| /* Fastest, least effective compression method & level provided by zlib. */ |
| #define SVN__COMPRESSION_ZLIB_MIN 1 |
| |
| /* Default compression method & level provided by zlib. */ |
| #define SVN__COMPRESSION_ZLIB_DEFAULT 5 |
| |
| /* Slowest, best compression method & level provided by zlib. */ |
| #define SVN__COMPRESSION_ZLIB_MAX 9 |
| |
| /* Encode VAL into the buffer P using the variable-length 7b/8b unsigned |
| integer format. Return the incremented value of P after the |
| encoded bytes have been written. P must point to a buffer of size |
| at least SVN__MAX_ENCODED_UINT_LEN. |
| |
| This encoding uses the high bit of each byte as a continuation bit |
| and the other seven bits as data bits. High-order data bits are |
| encoded first, followed by lower-order bits, so the value can be |
| reconstructed by concatenating the data bits from left to right and |
| interpreting the result as a binary number. Examples (brackets |
| denote byte boundaries, spaces are for clarity only): |
| |
| 1 encodes as [0 0000001] |
| 33 encodes as [0 0100001] |
| 129 encodes as [1 0000001] [0 0000001] |
| 2000 encodes as [1 0001111] [0 1010000] |
| */ |
| unsigned char * |
| svn__encode_uint(unsigned char *p, apr_uint64_t val); |
| |
| /* Wrapper around svn__encode_uint using the LSB to store the sign: |
| * |
| * If VAL >= 0 |
| * UINT_VAL = 2 * VAL |
| * else |
| * UINT_VAL = (- 2 * VAL) - 1 |
| */ |
| unsigned char * |
| svn__encode_int(unsigned char *p, apr_int64_t val); |
| |
| /* Decode an unsigned 7b/8b-encoded integer into *VAL and return a pointer |
| to the byte after the integer. The bytes to be decoded live in the |
| range [P..END-1]. If these bytes do not contain a whole encoded |
| integer, return NULL; in this case *VAL is undefined. |
| |
| See the comment for svn__encode_uint() earlier in this file for more |
| detail on the encoding format. */ |
| const unsigned char * |
| svn__decode_uint(apr_uint64_t *val, |
| const unsigned char *p, |
| const unsigned char *end); |
| |
| /* Wrapper around svn__decode_uint, reversing the transformation performed |
| * by svn__encode_int. |
| */ |
| const unsigned char * |
| svn__decode_int(apr_int64_t *val, |
| const unsigned char *p, |
| const unsigned char *end); |
| |
| /* Compress the data from DATA with length LEN, it according to the |
| * specified COMPRESSION_METHOD and write the result to OUT. |
| * SVN__COMPRESSION_NONE is valid for COMPRESSION_METHOD. |
| */ |
| svn_error_t * |
| svn__compress_zlib(const void *data, apr_size_t len, |
| svn_stringbuf_t *out, |
| int compression_method); |
| |
| /* Decompress the compressed data from DATA with length LEN and write the |
| * result to OUT. Return an error if the decompressed size is larger than |
| * LIMIT. |
| */ |
| svn_error_t * |
| svn__decompress_zlib(const void *data, apr_size_t len, |
| svn_stringbuf_t *out, |
| apr_size_t limit); |
| |
| /* Same as svn__compress_zlib(), but use LZ4 compression. Note that |
| * while the declaration of this function uses apr_size_t, it expects |
| * blocks of size not exceeding LZ4_MAX_INPUT_SIZE. The caller should |
| * ensure that the proper size is passed to this function. |
| */ |
| svn_error_t * |
| svn__compress_lz4(const void *data, apr_size_t len, |
| svn_stringbuf_t *out); |
| |
| /* Same as svn__decompress_zlib(), but use LZ4 compression. The caller |
| * should ensure that the size and limit passed to this function do not |
| * exceed INT_MAX. |
| */ |
| svn_error_t * |
| svn__decompress_lz4(const void *data, apr_size_t len, |
| svn_stringbuf_t *out, |
| apr_size_t limit); |
| |
| /** @} */ |
| |
| /** |
| * @defgroup svn_root_pools Recycle-able root pools API |
| * @{ |
| */ |
| |
| /* Opaque thread-safe container for unused / recylcleable root pools. |
| * |
| * Recyling root pools (actually, their allocators) circumvents a |
| * scalability bottleneck in the OS memory management when multi-threaded |
| * applications frequently create and destroy allocators. |
| */ |
| typedef struct svn_root_pools__t svn_root_pools__t; |
| |
| /* Create a new root pools container and return it in *POOLS. |
| */ |
| svn_error_t * |
| svn_root_pools__create(svn_root_pools__t **pools); |
| |
| /* Return a currently unused pool from POOLS. If POOLS is empty, create a |
| * new root pool and return that. The pool returned is not thread-safe. |
| */ |
| apr_pool_t * |
| svn_root_pools__acquire_pool(svn_root_pools__t *pools); |
| |
| /* Clear and release the given root POOL and put it back into POOLS. |
| * If that fails, destroy POOL. |
| */ |
| void |
| svn_root_pools__release_pool(apr_pool_t *pool, |
| svn_root_pools__t *pools); |
| |
| /** @} */ |
| |
| /** |
| * @defgroup svn_config_private Private configuration handling API |
| * @{ |
| */ |
| |
| /* Future attempts to modify CFG will trigger an assertion. */ |
| void |
| svn_config__set_read_only(svn_config_t *cfg, |
| apr_pool_t *scratch_pool); |
| |
| /* Return TRUE, if CFG cannot be modified. */ |
| svn_boolean_t |
| svn_config__is_read_only(svn_config_t *cfg); |
| |
| /* Return TRUE, if OPTION in SECTION in CFG exists and does not require |
| * further expansion (due to either containing no placeholders or already |
| * having been expanded). */ |
| svn_boolean_t |
| svn_config__is_expanded(svn_config_t *cfg, |
| const char *section, |
| const char *option); |
| |
| /* Return a shallow copy of SCR in POOL. If SRC is read-only, different |
| * shallow copies may be used from different threads. |
| * |
| * Any single r/o svn_config_t or shallow copy is not thread-safe because |
| * it contains shared buffers for tempoary data. |
| */ |
| svn_config_t * |
| svn_config__shallow_copy(svn_config_t *src, |
| apr_pool_t *pool); |
| |
| /* Add / replace SECTION in TARGET with the same section from SOURCE by |
| * simply adding a reference to it. If TARGET is read-only, the sections |
| * list in target gets duplicated before the modification. |
| * |
| * This is an API tailored for use by the svn_repos__authz_pool_t API to |
| * prevent breach of encapsulation. |
| */ |
| void |
| svn_config__shallow_replace_section(svn_config_t *target, |
| svn_config_t *source, |
| const char *section); |
| |
| /* Allocate *CFG_HASH and populate it with default, empty, |
| * svn_config_t for the configuration categories (@c |
| * SVN_CONFIG_CATEGORY_SERVERS, @c SVN_CONFIG_CATEGORY_CONFIG, etc.). |
| * This returns a hash equivalent to svn_config_get_config when the |
| * config files are empty. |
| */ |
| svn_error_t * |
| svn_config__get_default_config(apr_hash_t **cfg_hash, |
| apr_pool_t *pool); |
| |
| /** @} */ |
| |
| |
| /** |
| * @defgroup svn_bit_array Packed bit array handling API |
| * @{ |
| */ |
| |
| /* This opaque data struct is an alternative to an INT->VOID hash. |
| * |
| * Technically, it is an automatically growing packed bit array. |
| * All indexes not previously set are implicitly 0 and setting it will |
| * grow the array as needed. |
| */ |
| typedef struct svn_bit_array__t svn_bit_array__t; |
| |
| /* Return a new bit array allocated in POOL. MAX is a mere hint for |
| * the initial size of the array in bits. |
| */ |
| svn_bit_array__t * |
| svn_bit_array__create(apr_size_t max, |
| apr_pool_t *pool); |
| |
| /* Set bit at index IDX in ARRAY to VALUE. If necessary, grow the |
| * underlying data buffer, i.e. any IDX is valid unless we run OOM. |
| */ |
| void |
| svn_bit_array__set(svn_bit_array__t *array, |
| apr_size_t idx, |
| svn_boolean_t value); |
| |
| /* Get the bit value at index IDX in ARRAY. Bits not previously accessed |
| * are implicitly 0 (or FALSE). That implies IDX can never be out-of-range. |
| */ |
| svn_boolean_t |
| svn_bit_array__get(svn_bit_array__t *array, |
| apr_size_t idx); |
| |
| /* Return the global pool used by the DSO loader, this may be NULL if |
| no DSOs have been loaded. */ |
| apr_pool_t * |
| svn_dso__pool(void); |
| |
| /** @} */ |
| |
| |
| /* Return the xml (expat) version we compiled against. */ |
| const char *svn_xml__compiled_version(void); |
| |
| /* Return the xml (expat) version we run against. */ |
| const char *svn_xml__runtime_version(void); |
| |
| /* Return the zlib version we compiled against. */ |
| const char *svn_zlib__compiled_version(void); |
| |
| /* Return the zlib version we run against. */ |
| const char *svn_zlib__runtime_version(void); |
| |
| /* Return the lz4 version we compiled against. */ |
| const char *svn_lz4__compiled_version(void); |
| |
| /* Return the lz4 version we run against as a composed value: |
| * major * 100 * 100 + minor * 100 + release |
| */ |
| int svn_lz4__runtime_version(void); |
| |
| #ifdef __cplusplus |
| } |
| #endif /* __cplusplus */ |
| |
| #endif /* SVN_SUBR_PRIVATE_H */ |