/usr/include/CLucene/index/IndexDeletionPolicy.h is in libclucene-dev 2.3.3.4+dfsg-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | /*------------------------------------------------------------------------------
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
*
* Distributable under the terms of either the Apache License (Version 2.0) or
* the GNU Lesser General Public License, as specified in the COPYING file.
------------------------------------------------------------------------------*/
#ifndef _lucene_index_IndexDeletionPolicy_
#define _lucene_index_IndexDeletionPolicy_
#include <vector>
#include "CLucene/util/Equators.h"
CL_NS_DEF(index)
class CLUCENE_EXPORT IndexCommitPoint {
public:
virtual ~IndexCommitPoint();
/**
* Get the segments file (<code>segments_N</code>) associated
* with this commit point.
*/
virtual std::string getSegmentsFileName() = 0;
/**
* Returns all index files referenced by this commit point.
*/
virtual const std::vector<std::string>& getFileNames() = 0;
/**
* Delete this commit point.
* <p>
* Upon calling this, the writer is notified that this commit
* point should be deleted.
* <p>
* Decision that a commit-point should be deleted is taken by the {@link IndexDeletionPolicy} in effect
* and therefore this should only be called by its {@link IndexDeletionPolicy#onInit onInit()} or
* {@link IndexDeletionPolicy#onCommit onCommit()} methods.
*/
virtual void deleteCommitPoint() = 0;
};
/**
* <p>Expert: policy for deletion of stale {@link IndexCommitPoint index commits}.
*
* <p>Implement this interface, and pass it to one
* of the {@link IndexWriter} or {@link IndexReader}
* constructors, to customize when older
* {@link IndexCommitPoint point-in-time commits}
* are deleted from the index directory. The default deletion policy
* is {@link KeepOnlyLastCommitDeletionPolicy}, which always
* removes old commits as soon as a new commit is done (this
* matches the behavior before 2.2).</p>
*
* <p>One expected use case for this (and the reason why it
* was first created) is to work around problems with an
* index directory accessed via filesystems like NFS because
* NFS does not provide the "delete on last close" semantics
* that Lucene's "point in time" search normally relies on.
* By implementing a custom deletion policy, such as "a
* commit is only removed once it has been stale for more
* than X minutes", you can give your readers time to
* refresh to the new commit before {@link IndexWriter}
* removes the old commits. Note that doing so will
* increase the storage requirements of the index. See <a
* target="top"
* href="http://issues.apache.org/jira/browse/LUCENE-710">LUCENE-710</a>
* for details.</p>
*/
class CLUCENE_EXPORT IndexDeletionPolicy: public CL_NS(util)::NamedObject{
public:
virtual ~IndexDeletionPolicy();
/**
* <p>This is called once when a writer is first
* instantiated to give the policy a chance to remove old
* commit points.</p>
*
* <p>The writer locates all index commits present in the
* index directory and calls this method. The policy may
* choose to delete some of the commit points, doing so by
* calling method {@link IndexCommitPoint#delete delete()}
* of {@link IndexCommitPoint}.</p>
*
* <p><u>Note:</u> the last CommitPoint is the most recent one,
* i.e. the "front index state". Be careful not to delete it,
* unless you know for sure what you are doing, and unless
* you can afford to lose the index content while doing that.
*
* @param commits List of current
* {@link IndexCommitPoint point-in-time commits},
* sorted by age (the 0th one is the oldest commit).
*/
virtual void onInit(std::vector<IndexCommitPoint*>& commits) = 0;
/**
* <p>This is called each time the writer completed a commit.
* This gives the policy a chance to remove old commit points
* with each commit.</p>
*
* <p>The policy may now choose to delete old commit points
* by calling method {@link IndexCommitPoint#delete delete()}
* of {@link IndexCommitPoint}.</p>
*
* <p>If writer has <code>autoCommit = true</code> then
* this method will in general be called many times during
* one instance of {@link IndexWriter}. If
* <code>autoCommit = false</code> then this method is
* only called once when {@link IndexWriter#close} is
* called, or not at all if the {@link IndexWriter#abort}
* is called.
*
* <p><u>Note:</u> the last CommitPoint is the most recent one,
* i.e. the "front index state". Be careful not to delete it,
* unless you know for sure what you are doing, and unless
* you can afford to lose the index content while doing that.
*
* @param commits List of {@link IndexCommitPoint},
* sorted by age (the 0th one is the oldest commit).
*/
virtual void onCommit(std::vector<IndexCommitPoint*>& commits) = 0;
};
/**
* This {@link IndexDeletionPolicy} implementation that
* keeps only the most recent commit and immediately removes
* all prior commits after a new commit is done. This is
* the default deletion policy.
*/
class CLUCENE_EXPORT KeepOnlyLastCommitDeletionPolicy: public IndexDeletionPolicy {
public:
virtual ~KeepOnlyLastCommitDeletionPolicy();
/**
* Deletes all commits except the most recent one.
*/
void onInit(std::vector<IndexCommitPoint*>& commits);
/**
* Deletes all commits except the most recent one.
*/
void onCommit(std::vector<IndexCommitPoint*>& commits);
static const char* getClassName();
const char* getObjectName() const;
};
CL_NS_END
#endif
|