rust/hg-core/src/dirstate_tree/on_disk.rs
changeset 48260 269ff8978086
parent 48254 b874e8d81a98
child 48261 9205d9be8b41
equal deleted inserted replaced
48259:84f6b0c41b90 48260:269ff8978086
   315 
   315 
   316     pub(super) fn node_data(
   316     pub(super) fn node_data(
   317         &self,
   317         &self,
   318     ) -> Result<dirstate_map::NodeData, DirstateV2ParseError> {
   318     ) -> Result<dirstate_map::NodeData, DirstateV2ParseError> {
   319         if self.has_entry() {
   319         if self.has_entry() {
   320             Ok(dirstate_map::NodeData::Entry(self.assume_entry()))
   320             Ok(dirstate_map::NodeData::Entry(self.assume_entry()?))
   321         } else if let Some(mtime) = self.cached_directory_mtime()? {
   321         } else if let Some(mtime) = self.cached_directory_mtime()? {
   322             Ok(dirstate_map::NodeData::CachedDirectory { mtime })
   322             Ok(dirstate_map::NodeData::CachedDirectory { mtime })
   323         } else {
   323         } else {
   324             Ok(dirstate_map::NodeData::None)
   324             Ok(dirstate_map::NodeData::None)
   325         }
   325         }
   355             0o644
   355             0o644
   356         };
   356         };
   357         file_type | permisions
   357         file_type | permisions
   358     }
   358     }
   359 
   359 
   360     fn assume_entry(&self) -> DirstateEntry {
   360     fn assume_entry(&self) -> Result<DirstateEntry, DirstateV2ParseError> {
   361         // TODO: convert through raw bits instead?
   361         // TODO: convert through raw bits instead?
   362         let wdir_tracked = self.flags().contains(Flags::WDIR_TRACKED);
   362         let wdir_tracked = self.flags().contains(Flags::WDIR_TRACKED);
   363         let p1_tracked = self.flags().contains(Flags::P1_TRACKED);
   363         let p1_tracked = self.flags().contains(Flags::P1_TRACKED);
   364         let p2_info = self.flags().contains(Flags::P2_INFO);
   364         let p2_info = self.flags().contains(Flags::P2_INFO);
   365         let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE)
   365         let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE)
   370             None
   370             None
   371         };
   371         };
   372         let mtime = if self.flags().contains(Flags::HAS_FILE_MTIME)
   372         let mtime = if self.flags().contains(Flags::HAS_FILE_MTIME)
   373             && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
   373             && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
   374         {
   374         {
   375             Some(self.mtime.truncated_seconds.into())
   375             // TODO: replace this by `self.mtime.try_into()?` to use
       
   376             // sub-second precision from the file.
       
   377             // We don’t do this yet because other parts of the code
       
   378             // always set it to zero.
       
   379             let mtime = TruncatedTimestamp::from_already_truncated(
       
   380                 self.mtime.truncated_seconds.get(),
       
   381                 0,
       
   382             )?;
       
   383             Some(mtime)
   376         } else {
   384         } else {
   377             None
   385             None
   378         };
   386         };
   379         DirstateEntry::from_v2_data(
   387         Ok(DirstateEntry::from_v2_data(
   380             wdir_tracked,
   388             wdir_tracked,
   381             p1_tracked,
   389             p1_tracked,
   382             p2_info,
   390             p2_info,
   383             mode_size,
   391             mode_size,
   384             mtime,
   392             mtime,
   385             None,
   393             None,
   386             None,
   394             None,
   387         )
   395         ))
   388     }
   396     }
   389 
   397 
   390     pub(super) fn entry(
   398     pub(super) fn entry(
   391         &self,
   399         &self,
   392     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
   400     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
   393         if self.has_entry() {
   401         if self.has_entry() {
   394             Ok(Some(self.assume_entry()))
   402             Ok(Some(self.assume_entry()?))
   395         } else {
   403         } else {
   396             Ok(None)
   404             Ok(None)
   397         }
   405         }
   398     }
   406     }
   399 
   407 
   448         } else {
   456         } else {
   449             0.into()
   457             0.into()
   450         };
   458         };
   451         let mtime = if let Some(m) = mtime_opt {
   459         let mtime = if let Some(m) = mtime_opt {
   452             flags.insert(Flags::HAS_FILE_MTIME);
   460             flags.insert(Flags::HAS_FILE_MTIME);
   453             PackedTruncatedTimestamp {
   461             m.into()
   454                 truncated_seconds: m.into(),
       
   455                 nanoseconds: 0.into(),
       
   456             }
       
   457         } else {
   462         } else {
   458             PackedTruncatedTimestamp::null()
   463             PackedTruncatedTimestamp::null()
   459         };
   464         };
   460         if let Some(f_exec) = fallback_exec {
   465         if let Some(f_exec) = fallback_exec {
   461             flags.insert(Flags::HAS_FALLBACK_EXEC);
   466             flags.insert(Flags::HAS_FALLBACK_EXEC);