subversion/libsvn_fs_base/id.c

   1 /* id.c : operations on node-revision IDs
   2  *
   3  * ====================================================================
   4  * Copyright (c) 2000-2004 CollabNet.  All rights reserved.
   5  *
   6  * This software is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at http://subversion.tigris.org/license-1.html.
   9  * If newer versions of this license are posted there, you may use a
  10  * newer version instead, at your option.
  11  *
  12  * This software consists of voluntary contributions made by many
  13  * individuals.  For exact contribution history, see the revision
  14  * history and logs, available at http://subversion.tigris.org/.
  15  * ====================================================================
  16  */
  17
  18 #include <string.h>
  19 #include <stdlib.h>
  20
  21 #include "id.h"
  22 #include "../libsvn_fs/fs-loader.h"
  23
  24
  25 \f
  26 typedef struct {
  27   const char *node_id;
  28   const char *copy_id;
  29   const char *txn_id;
  30 } id_private_t;
  31
  32 \f
  33 /* Accessing ID Pieces.  */
  34
  35 const char *
  36 svn_fs_base__id_node_id(const svn_fs_id_t *id)
  37 {
  38   id_private_t *pvt = id->fsap_data;
  39
  40   return pvt->node_id;
  41 }
  42
  43
  44 const char *
  45 svn_fs_base__id_copy_id(const svn_fs_id_t *id)
  46 {
  47   id_private_t *pvt = id->fsap_data;
  48
  49   return pvt->copy_id;
  50 }
  51
  52
  53 const char *
  54 svn_fs_base__id_txn_id(const svn_fs_id_t *id)
  55 {
  56   id_private_t *pvt = id->fsap_data;
  57
  58   return pvt->txn_id;
  59 }
  60
  61
  62 svn_string_t *
  63 svn_fs_base__id_unparse(const svn_fs_id_t *id,
  64                         apr_pool_t *pool)
  65 {
  66   id_private_t *pvt = id->fsap_data;
  67
  68   return svn_string_createf(pool, "%s.%s.%s",
  69                             pvt->node_id, pvt->copy_id, pvt->txn_id);
  70 }
  71
  72 \f
  73 /*** Comparing node IDs ***/
  74
  75 svn_boolean_t
  76 svn_fs_base__id_eq(const svn_fs_id_t *a,
  77                    const svn_fs_id_t *b)
  78 {
  79   id_private_t *pvta = a->fsap_data, *pvtb = b->fsap_data;
  80
  81   if (a == b)
  82     return TRUE;
  83   if (strcmp(pvta->node_id, pvtb->node_id) != 0)
  84      return FALSE;
  85   if (strcmp(pvta->copy_id, pvtb->copy_id) != 0)
  86     return FALSE;
  87   if (strcmp(pvta->txn_id, pvtb->txn_id) != 0)
  88     return FALSE;
  89   return TRUE;
  90 }
  91
  92
  93 svn_boolean_t
  94 svn_fs_base__id_check_related(const svn_fs_id_t *a,
  95                               const svn_fs_id_t *b)
  96 {
  97   id_private_t *pvta = a->fsap_data, *pvtb = b->fsap_data;
  98
  99   if (a == b)
 100     return TRUE;
 101
 102   return (strcmp(pvta->node_id, pvtb->node_id) == 0) ? TRUE : FALSE;
 103 }
 104
 105
 106 int
 107 svn_fs_base__id_compare(const svn_fs_id_t *a,
 108                         const svn_fs_id_t *b)
 109 {
 110   if (svn_fs_base__id_eq(a, b))
 111     return 0;
 112   return (svn_fs_base__id_check_related(a, b) ? 1 : -1);
 113 }
 114
 115
 116 \f
 117 /* Creating ID's.  */
 118
 119 static id_vtable_t id_vtable = {
 120   svn_fs_base__id_unparse,
 121   svn_fs_base__id_compare
 122 };
 123
 124
 125 svn_fs_id_t *
 126 svn_fs_base__id_create(const char *node_id,
 127                        const char *copy_id,
 128                        const char *txn_id,
 129                        apr_pool_t *pool)
 130 {
 131   svn_fs_id_t *id = apr_palloc(pool, sizeof(*id));
 132   id_private_t *pvt = apr_palloc(pool, sizeof(*pvt));
 133
 134   pvt->node_id = apr_pstrdup(pool, node_id);
 135   pvt->copy_id = apr_pstrdup(pool, copy_id);
 136   pvt->txn_id = apr_pstrdup(pool, txn_id);
 137   id->vtable = &id_vtable;
 138   id->fsap_data = pvt;
 139   return id;
 140 }
 141
 142
 143 svn_fs_id_t *
 144 svn_fs_base__id_copy(const svn_fs_id_t *id, apr_pool_t *pool)
 145 {
 146   svn_fs_id_t *new_id = apr_palloc(pool, sizeof(*new_id));
 147   id_private_t *new_pvt = apr_palloc(pool, sizeof(*new_pvt));
 148   id_private_t *pvt = id->fsap_data;
 149
 150   new_pvt->node_id = apr_pstrdup(pool, pvt->node_id);
 151   new_pvt->copy_id = apr_pstrdup(pool, pvt->copy_id);
 152   new_pvt->txn_id = apr_pstrdup(pool, pvt->txn_id);
 153   new_id->vtable = &id_vtable;
 154   new_id->fsap_data = new_pvt;
 155   return new_id;
 156 }
 157
 158
 159 svn_fs_id_t *
 160 svn_fs_base__id_parse(const char *data,
 161                       apr_size_t len,
 162                       apr_pool_t *pool)
 163 {
 164   svn_fs_id_t *id;
 165   id_private_t *pvt;
 166   char *data_copy, *str, *last_str;
 167
 168   /* Dup the ID data into POOL.  Our returned ID will have references
 169      into this memory. */
 170   data_copy = apr_pstrmemdup(pool, data, len);
 171
 172   /* Alloc a new svn_fs_id_t structure. */
 173   id = apr_palloc(pool, sizeof(*id));
 174   pvt = apr_palloc(pool, sizeof(*pvt));
 175   id->vtable = &id_vtable;
 176   id->fsap_data = pvt;
 177
 178   /* Now, we basically just need to "split" this data on `.'
 179      characters.  We will use apr_strtok, which will put terminators
 180      where each of the '.'s used to be.  Then our new id field will
 181      reference string locations inside our duplicate string.*/
 182
 183   /* Node Id */
 184   str = apr_strtok(data_copy, ".", &last_str);
 185   if (str == NULL)
 186     return NULL;
 187   pvt->node_id = str;
 188
 189   /* Copy Id */
 190   str = apr_strtok(NULL, ".", &last_str);
 191   if (str == NULL)
 192     return NULL;
 193   pvt->copy_id = str;
 194
 195   /* Txn Id */
 196   str = apr_strtok(NULL, ".", &last_str);
 197   if (str == NULL)
 198     return NULL;
 199   pvt->txn_id = str;
 200
 201   return id;
 202 }