/* low_level.c --- low level r/w access to FSX file structures
 *
 * ====================================================================
 *    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_LIBSVN_FS_X_LOW_LEVEL_H
#define SVN_LIBSVN_FS_X_LOW_LEVEL_H

#include "svn_fs.h"

#include "fs_x.h"
#include "id.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/* Kinds that a node-rev can be. */
#define SVN_FS_X__KIND_FILE          "file"
#define SVN_FS_X__KIND_DIR           "dir"

/* The functions are grouped as follows:
 *
 * - revision footer
 * - representation (as in "text:" and "props:" lines)
 * - node revision
 * - representation header ("DELTA" lines)
 * - changed path list
 */

/* Given the FSX revision / pack FOOTER, parse it destructively
 * and return the start offsets of the index data in *L2P_OFFSET and
 * *P2L_OFFSET, respectively.  Also, return the expected checksums in
 * in *L2P_CHECKSUM and *P2L_CHECKSUM.
 *
 * FOOTER_OFFSET is used for validation.
 *
 * Note that REV is only used to construct nicer error objects that
 * mention this revision.  Allocate the checksums in RESULT_POOL.
 */
svn_error_t *
svn_fs_x__parse_footer(apr_off_t *l2p_offset,
                       svn_checksum_t **l2p_checksum,
                       apr_off_t *p2l_offset,
                       svn_checksum_t **p2l_checksum,
                       svn_stringbuf_t *footer,
                       svn_revnum_t rev,
                       apr_off_t footer_offset,
                       apr_pool_t *result_pool);

/* Given the offset of the L2P index data in L2P_OFFSET, the content
 * checksum in L2P_CHECKSUM and the offset plus checksum of the P2L
 * index data in P2L_OFFSET and P2L_CHECKSUM.
 *
 * Return the corresponding format 7+ revision / pack file footer.
 * Allocate it in RESULT_POOL and use SCRATCH_POOL for temporary.
 */
svn_stringbuf_t *
svn_fs_x__unparse_footer(apr_off_t l2p_offset,
                         svn_checksum_t *l2p_checksum,
                         apr_off_t p2l_offset,
                         svn_checksum_t *p2l_checksum,
                         apr_pool_t *result_pool,
                         apr_pool_t *scratch_pool);

/* Parse the description of a representation from TEXT and store it
   into *REP_P.  TEXT will be invalidated by this call.  Allocate *REP_P in
   RESULT_POOL and use SCRATCH_POOL for temporaries. */
svn_error_t *
svn_fs_x__parse_representation(svn_fs_x__representation_t **rep_p,
                               svn_stringbuf_t *text,
                               apr_pool_t *result_pool,
                               apr_pool_t *scratch_pool);

/* Return a formatted string that represents the location of representation
 * REP.  If MUTABLE_REP_TRUNCATED is given, the rep is for props or dir
 * contents, and only a "-1" revision number will be given for a mutable rep.
 * If MAY_BE_CORRUPT is true, guard for NULL when constructing the string.
 * Allocate the result in RESULT_POOL and temporaries in SCRATCH_POOL. */
svn_stringbuf_t *
svn_fs_x__unparse_representation(svn_fs_x__representation_t *rep,
                                 svn_boolean_t mutable_rep_truncated,
                                 apr_pool_t *result_pool,
                                 apr_pool_t *scratch_pool);

/* Read a node-revision from STREAM. Set *NODEREV to the new structure,
   allocated in RESULT_POOL. */
svn_error_t *
svn_fs_x__read_noderev(svn_fs_x__noderev_t **noderev,
                       svn_stream_t *stream,
                       apr_pool_t *result_pool,
                       apr_pool_t *scratch_pool);

/* Write the node-revision NODEREV into the stream OUTFILE.
   Temporary allocations are from SCRATCH_POOL. */
svn_error_t *
svn_fs_x__write_noderev(svn_stream_t *outfile,
                        svn_fs_x__noderev_t *noderev,
                        apr_pool_t *scratch_pool);

/* This type enumerates all forms of representations that we support. */
typedef enum svn_fs_x__rep_type_t
{
  /* this is a DELTA representation with no base representation */
  svn_fs_x__rep_self_delta,

  /* this is a DELTA representation against some base representation */
  svn_fs_x__rep_delta,

  /* this is a representation in a star-delta container */
  svn_fs_x__rep_container
} svn_fs_x__rep_type_t;

/* This structure is used to hold the information stored in a representation
 * header. */
typedef struct svn_fs_x__rep_header_t
{
  /* type of the representation, i.e. whether self-DELTA etc. */
  svn_fs_x__rep_type_t type;

  /* if this rep is a delta against some other rep, that base rep can
   * be found in this revision.  Should be 0 if there is no base rep. */
  svn_revnum_t base_revision;

  /* if this rep is a delta against some other rep, that base rep can
   * be found at this item index within the base rep's revision.  Should
   * be 0 if there is no base rep. */
  apr_off_t base_item_index;

  /* if this rep is a delta against some other rep, this is the (deltified)
   * size of that base rep.  Should be 0 if there is no base rep. */
  svn_filesize_t base_length;

  /* length of the textual representation of the header in the rep or pack
   * file, including EOL.  Only valid after reading it from disk.
   * Should be 0 otherwise. */
  apr_size_t header_size;
} svn_fs_x__rep_header_t;

/* Read the next line from STREAM and parse it as a text
   representation header.  Return the parsed entry in *HEADER, allocated
   in RESULT_POOL. Perform temporary allocations in SCRATCH_POOL. */
svn_error_t *
svn_fs_x__read_rep_header(svn_fs_x__rep_header_t **header,
                          svn_stream_t *stream,
                          apr_pool_t *result_pool,
                          apr_pool_t *scratch_pool);

/* Write the representation HEADER to STREAM.
 * Use SCRATCH_POOL for allocations. */
svn_error_t *
svn_fs_x__write_rep_header(svn_fs_x__rep_header_t *header,
                           svn_stream_t *stream,
                           apr_pool_t *scratch_pool);

/* Read up to MAX_COUNT of the changes from STREAM and store them in
   *CHANGES, allocated in RESULT_POOL.  Do temporary allocations in
   SCRATCH_POOL. */
svn_error_t *
svn_fs_x__read_changes(apr_array_header_t **changes,
                       svn_stream_t *stream,
                       int max_count,
                       apr_pool_t *result_pool,
                       apr_pool_t *scratch_pool);

/* Callback function used by svn_fs_x__read_changes_incrementally(),
 * asking the receiver to process to process CHANGE using BATON.  CHANGE
 * and SCRATCH_POOL will not be valid beyond the current callback invocation.
 */
typedef svn_error_t *(*svn_fs_x__change_receiver_t)(
  void *baton,
  svn_fs_x__change_t *change,
  apr_pool_t *scratch_pool);

/* Read all the changes from STREAM and invoke CHANGE_RECEIVER on each change.
   Do all allocations in SCRATCH_POOL. */
svn_error_t *
svn_fs_x__read_changes_incrementally(svn_stream_t *stream,
                                     svn_fs_x__change_receiver_t
                                       change_receiver,
                                     void *change_receiver_baton,
                                     apr_pool_t *scratch_pool);

/* Write the changed path info from CHANGES in filesystem FS to the
   output stream STREAM.  You may call this function multiple time on
   the same stream.  If you are writing to a (proto-)revision file,
   the last call must set TERMINATE_LIST to write an extra empty line
   that marks the end of the changed paths list.
   Perform temporary allocations in SCRATCH_POOL.
 */
svn_error_t *
svn_fs_x__write_changes(svn_stream_t *stream,
                        svn_fs_t *fs,
                        apr_hash_t *changes,
                        svn_boolean_t terminate_list,
                        apr_pool_t *scratch_pool);

/* Parse the property list serialized in CONTENT and return it in
   *PROPERTIES, allocated from RESULT_POOL.  CONTENT must remain
   valid at least until the next cleanup of RESULT_POOL.
 */
svn_error_t *
svn_fs_x__parse_properties(apr_hash_t **properties,
                           const svn_string_t *content,
                           apr_pool_t *result_pool);

/* Write the property list PROPLIST to STREAM in serialized format.
   Use SCRATCH_POOL for temporary allocations.
 */
svn_error_t *
svn_fs_x__write_properties(svn_stream_t *stream,
                           apr_hash_t *proplist,
                           apr_pool_t *scratch_pool);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* SVN_LIBSVN_FS_X_LOW_LEVEL_H */