← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/ADT/OwningPtr.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/ADT/OwningPtr.h
 
1
//===- llvm/ADT/OwningPtr.h - Smart ptr that owns the pointee ---*- C++ -*-===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This file defines and implements the OwningPtr class.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef LLVM_ADT_OWNING_PTR_H
 
15
#define LLVM_ADT_OWNING_PTR_H
 
16
 
 
17
#include <cassert>
 
18
#include <cstddef>
 
19
 
 
20
namespace llvm {
 
21
 
 
22
/// OwningPtr smart pointer - OwningPtr mimics a built-in pointer except that it
 
23
/// guarantees deletion of the object pointed to, either on destruction of the
 
24
/// OwningPtr or via an explicit reset().  Once created, ownership of the
 
25
/// pointee object can be taken away from OwningPtr by using the take method.
 
26
template<class T>
 
27
class OwningPtr {
 
28
  OwningPtr(OwningPtr const &);             // DO NOT IMPLEMENT
 
29
  OwningPtr &operator=(OwningPtr const &);  // DO NOT IMPLEMENT
 
30
  T *Ptr;
 
31
public:
 
32
  explicit OwningPtr(T *P = 0) : Ptr(P) {}
 
33
 
 
34
  ~OwningPtr() {
 
35
    delete Ptr;
 
36
  }
 
37
 
 
38
  /// reset - Change the current pointee to the specified pointer.  Note that
 
39
  /// calling this with any pointer (including a null pointer) deletes the
 
40
  /// current pointer.
 
41
  void reset(T *P = 0) {
 
42
    if (P == Ptr) return;
 
43
    T *Tmp = Ptr;
 
44
    Ptr = P;
 
45
    delete Tmp;
 
46
  }
 
47
 
 
48
  /// take - Reset the owning pointer to null and return its pointer.  This does
 
49
  /// not delete the pointer before returning it.
 
50
  T *take() {
 
51
    T *Tmp = Ptr;
 
52
    Ptr = 0;
 
53
    return Tmp;
 
54
  }
 
55
 
 
56
  T &operator*() const {
 
57
    assert(Ptr && "Cannot dereference null pointer");
 
58
    return *Ptr;
 
59
  }
 
60
 
 
61
  T *operator->() const { return Ptr; }
 
62
  T *get() const { return Ptr; }
 
63
  operator bool() const { return Ptr != 0; }
 
64
  bool operator!() const { return Ptr == 0; }
 
65
 
 
66
  void swap(OwningPtr &RHS) {
 
67
    T *Tmp = RHS.Ptr;
 
68
    RHS.Ptr = Ptr;
 
69
    Ptr = Tmp;
 
70
  }
 
71
};
 
72
 
 
73
template<class T>
 
74
inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) {
 
75
  a.swap(b);
 
76
}
 
77
 
 
78
/// OwningArrayPtr smart pointer - OwningArrayPtr provides the same
 
79
///  functionality as OwningPtr, except that it works for array types.
 
80
template<class T>
 
81
class OwningArrayPtr {
 
82
  OwningArrayPtr(OwningArrayPtr const &);            // DO NOT IMPLEMENT
 
83
  OwningArrayPtr &operator=(OwningArrayPtr const &); // DO NOT IMPLEMENT
 
84
  T *Ptr;
 
85
public:
 
86
  explicit OwningArrayPtr(T *P = 0) : Ptr(P) {}
 
87
 
 
88
  ~OwningArrayPtr() {
 
89
    delete [] Ptr;
 
90
  }
 
91
 
 
92
  /// reset - Change the current pointee to the specified pointer.  Note that
 
93
  /// calling this with any pointer (including a null pointer) deletes the
 
94
  /// current pointer.
 
95
  void reset(T *P = 0) {
 
96
    if (P == Ptr) return;
 
97
    T *Tmp = Ptr;
 
98
    Ptr = P;
 
99
    delete [] Tmp;
 
100
  }
 
101
 
 
102
  /// take - Reset the owning pointer to null and return its pointer.  This does
 
103
  /// not delete the pointer before returning it.
 
104
  T *take() {
 
105
    T *Tmp = Ptr;
 
106
    Ptr = 0;
 
107
    return Tmp;
 
108
  }
 
109
 
 
110
  T &operator[](std::ptrdiff_t i) const {
 
111
    assert(Ptr && "Cannot dereference null pointer");
 
112
    return Ptr[i];
 
113
  }
 
114
 
 
115
  T *get() const { return Ptr; }
 
116
  operator bool() const { return Ptr != 0; }
 
117
  bool operator!() const { return Ptr == 0; }
 
118
 
 
119
  void swap(OwningArrayPtr &RHS) {
 
120
    T *Tmp = RHS.Ptr;
 
121
    RHS.Ptr = Ptr;
 
122
    Ptr = Tmp;
 
123
  }
 
124
};
 
125
 
 
126
template<class T>
 
127
inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) {
 
128
  a.swap(b);
 
129
}
 
130
 
 
131
 
 
132
} // end namespace llvm
 
133
 
 
134
#endif