Skip to Navigation

User login

Username: *

Password: *

• Request new password

• jigdo
• Development
• Debian jigdo mini-HOWTO

Home › jigdo › Development › jigdo API

jigdo API

Last update by Admin on 2010-05-23

• Namespaces
• Class hierarchy
• Class list
• File list
• Namespace Members
• Class Members
• File Members

partialmatch.hh

Go to the documentation of this file.

/* $Id: partialmatch.hh,v 1.1.1.1 2003/07/04 22:29:14 atterer Exp $ -*- C++ -*-
  __   _
  |_) /|  Copyright (C) 2002  |  richard@
  | \/¯|  Richard Atterer     |  atterer.net
  ¯ '` ¯
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License, version 2. See
  the file COPYING for details.

*/
#ifndef PARTIALMATCH_HH
#include <debug.hh>
#include <log.hh>
#define PARTIALMATCH_HH

#ifndef INLINE
#  ifdef NOINLINE
#    define INLINE
#    else
#    define INLINE inline
#  endif
#endif

class MkTemplate::PartialMatch {
  friend class MkTemplate::PartialMatchQueue;
public:
  uint64 startOffset() const { return startOff; }
  void setStartOffset(uint64 o) { startOff = o; }

  uint64 nextEvent() const { return nextEv; }
  INLINE void setNextEvent(PartialMatchQueue* matches, uint64 newNextEvent);

  size_t blockOffset() const { return blockOff; }
  void setBlockOffset(size_t b) { blockOff = b; }

  size_t blockNumber() const { return blockNr; }
  void setBlockNumber(size_t b) { blockNr = b; }

  FilePart* file() const { return filePart; }
  void setFile(FilePart* f) { filePart = f; }

  PartialMatch* next() const { return nextPart; }

private:
  PartialMatch() { } // Only to be instantiated by PartialMatchQueue
  uint64 startOff; // Offset in image at which this match starts
  uint64 nextEv; // Next value of off at which to finish() sum & compare
  size_t blockOff; // Offset in buf of start of current MD5 block
  size_t blockNr; // Number of block in file, i.e. index into file->sums[]
  FilePart* filePart; // File whose sums matched so far
  PartialMatch* nextPart;
  bool operator<=(const PartialMatch& x) {
    return nextEvent() <= x.nextEvent();
  }
};
//________________________________________

class MkTemplate::PartialMatchQueue {
  friend class MkTemplate::PartialMatch;
public:
  inline PartialMatchQueue();

  bool empty() const { return head == 0; }

  bool full() const { return freeHead == 0; }

  /* If true is returned, the queue is not only full, findDropCandidate() is
      also going to always return 0 from now on. Intended to be used for
      optimisation: As long as crammed()==true, needn't even check for
      further prospective matches.
      The value returned by this function is set to true by
      findDropCandidate(), and set to false by erase(), eraseFront(),
      eraseStartOffsetLess() and setNextEvent(). (NB not by
      setStartOffset()) */
  //bool crammed() const { return crammedVal; }

  PartialMatch* front() const { return head; }

  INLINE PartialMatch* addFront();

  INLINE PartialMatch* lowestStartOffset() const;

  INLINE uint64 nextEvent() const;

  INLINE PartialMatch* findStartOffset(uint64 off) const;

  INLINE PartialMatch* findLowestStartOffset() const;

  inline void erase();

  INLINE void eraseFront();

  INLINE void eraseStartOffsetLess(uint64 off);

  INLINE PartialMatch* findDropCandidate(unsigned* sectorLength,
                                         uint64 newStartOffset);

# if DEBUG
  void consistencyCheck() const;
# else
  void consistencyCheck() const { }
# endif

private:
  /* The size of the linked list of MD5 blocks awaiting matching must
     be limited for cases where there are lots of overlapping matches,
     e.g. both image and a file are all zeroes. */
  static const int MAX_MATCHES = 2048;
  PartialMatch* head; // First entry of queue, or null if queue empty
  PartialMatch* freeHead; // First elem of linked list of free slots, or null
  PartialMatch data[MAX_MATCHES];

  /* If true, queue is full, and furthermore findDropCandidate() will always
     return 0 */
  //bool crammedVal;
};
//______________________________________________________________________

void MkTemplate::PartialMatchQueue::erase() {
  head = 0;
  freeHead = &data[0];
  //crammedVal = false;
  // Put all elements in free list
  data[MAX_MATCHES - 1].nextPart = 0;
  for (int i = MAX_MATCHES - 2; i >= 0; --i)
    data[i].nextPart = &data[i + 1];
  consistencyCheck();
}

MkTemplate::PartialMatchQueue::PartialMatchQueue() {
  erase();
}
//______________________________________________________________________

#ifndef NOINLINE
#  include <partialmatch.ih> /* NOINLINE */
#endif

#endif

---

• Photography
• Software
• jigdo
• Research
• About

© Copyright 2014 Richard Atterer

 Top of page  •  Home  •  Sitemap  •  Contact  •  About