DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (6cbf1430a66e)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
//* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef ChunkSet_h__
#define ChunkSet_h__

#include "Entries.h"
#include "nsString.h"
#include "nsTArray.h"

namespace mozilla {
namespace safebrowsing {

/**
 * Store the chunk numbers as an array of ranges of uint32_t.
 * We need chunk numbers in order to ask for incremental updates from the
 * server.
 */
class ChunkSet {
 public:
  nsresult Serialize(nsACString& aStr);
  nsresult Set(uint32_t aChunk);
  bool Has(uint32_t chunk) const;
  nsresult Merge(const ChunkSet& aOther);
  uint32_t Length() const;
  nsresult Remove(const ChunkSet& aOther);
  void Clear();

  nsresult Write(nsIOutputStream* aOut) const;
  nsresult Read(nsIInputStream* aIn, uint32_t aNumElements);

 private:
  class Range {
   public:
    Range(uint32_t aBegin, uint32_t aEnd) : mBegin(aBegin), mEnd(aEnd) {}

    uint32_t Length() const;
    nsresult Remove(const Range& aRange, ChunkSet& aRemainderSet) const;
    bool FoldLeft(const Range& aRange);

    bool operator==(const Range& rhs) const { return mBegin == rhs.mBegin; }
    bool operator<(const Range& rhs) const { return mBegin < rhs.mBegin; }

    uint32_t Begin() const { return mBegin; }
    void Begin(const uint32_t aBegin) { mBegin = aBegin; }
    uint32_t End() const { return mEnd; }
    void End(const uint32_t aEnd) { mEnd = aEnd; }

    bool Contains(const Range& aRange) const {
      return mBegin <= aRange.mBegin && aRange.mEnd <= mEnd;
    }
    bool Precedes(const Range& aRange) const {
      return mEnd + 1 == aRange.mBegin;
    }

    struct IntersectionComparator {
      int operator()(const Range& aRange) const {
        if (aRange.mBegin > mTarget.mEnd) {
          return -1;
        }
        if (mTarget.mBegin > aRange.mEnd) {
          return 1;
        }
        return 0;
      }

      explicit IntersectionComparator(const Range& aTarget)
          : mTarget(aTarget) {}
      const Range& mTarget;
    };

   private:
    uint32_t mBegin;
    uint32_t mEnd;
  };

  static const size_t IO_BUFFER_SIZE = 1024;
  FallibleTArray<Range> mRanges;

  bool HasSubrange(const Range& aSubrange) const;
};

}  // namespace safebrowsing
}  // namespace mozilla

#endif