1 use bytes_cast::BytesCast;

     1 use bytes_cast::BytesCast;

     3 use std::borrow::Cow;

     2 use std::borrow::Cow;

     4 use std::path::PathBuf;

     3 use std::path::PathBuf;

     5 

     4 

     6 use super::on_disk;

     5 use super::on_disk;

     7 use super::on_disk::DirstateV2ParseError;

     6 use super::on_disk::DirstateV2ParseError;

   452             old_data_size: 0,

   451             old_data_size: 0,

   453             dirstate_version: DirstateVersion::V1,

   452             dirstate_version: DirstateVersion::V1,

   454         }

   453         }

   455     }

   454     }

   456 

   455 

   458     pub fn new_v2(

   457     pub fn new_v2(

   459         on_disk: &'on_disk [u8],

   458         on_disk: &'on_disk [u8],

   460         data_size: usize,

   459         data_size: usize,

   461         metadata: &[u8],

   460         metadata: &[u8],

   462     ) -> Result<Self, DirstateError> {

   461     ) -> Result<Self, DirstateError> {

   465         } else {

   464         } else {

   466             Err(DirstateV2ParseError::new("not enough bytes on disk").into())

   465             Err(DirstateV2ParseError::new("not enough bytes on disk").into())

   467         }

   466         }

   468     }

   467     }

   469 

   468 

   471     pub fn new_v1(

   470     pub fn new_v1(

   472         on_disk: &'on_disk [u8],

   471         on_disk: &'on_disk [u8],

   473     ) -> Result<(Self, Option<DirstateParents>), DirstateError> {

   472     ) -> Result<(Self, Option<DirstateParents>), DirstateError> {

   474         let mut map = Self::empty(on_disk);

   473         let mut map = Self::empty(on_disk);

   475         if map.on_disk.is_empty() {

   474         if map.on_disk.is_empty() {

  1206                 Ok(false)

  1205                 Ok(false)

  1207             }

  1206             }

  1208         })

  1207         })

  1209     }

  1208     }

  1210 

  1209 

  1212     pub fn pack_v1(

  1211     pub fn pack_v1(

  1213         &self,

  1212         &self,

  1214         parents: DirstateParents,

  1213         parents: DirstateParents,

  1215     ) -> Result<Vec<u8>, DirstateError> {

  1214     ) -> Result<Vec<u8>, DirstateError> {

  1216         let map = self.get_map();

  1215         let map = self.get_map();

  1246 

  1245 

  1247     /// Returns new data and metadata together with whether that data should be

  1246     /// Returns new data and metadata together with whether that data should be

  1248     /// appended to the existing data file whose content is at

  1247     /// appended to the existing data file whose content is at

  1249     /// `map.on_disk` (true), instead of written to a new data file

  1248     /// `map.on_disk` (true), instead of written to a new data file

  1250     /// (false), and the previous size of data on disk.

  1249     /// (false), and the previous size of data on disk.

  1252     pub fn pack_v2(

  1251     pub fn pack_v2(

  1253         &self,

  1252         &self,

  1254         can_append: bool,

  1253         can_append: bool,

  1255     ) -> Result<(Vec<u8>, on_disk::TreeMetadata, bool, usize), DirstateError>

  1254     ) -> Result<(Vec<u8>, on_disk::TreeMetadata, bool, usize), DirstateError>

  1256     {

  1255     {