/usr/include/ITK-4.5/itkThreadedIteratorRangePartitioner.h is in libinsighttoolkit4-dev 4.5.0-3.
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 153 154 155 156 157 158 159 160 161 | /*=========================================================================
*
* Copyright Insight Software Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef __itkThreadedIteratorRangePartitioner_h
#define __itkThreadedIteratorRangePartitioner_h
#include "itkThreadedDomainPartitioner.h"
namespace itk
{
template< typename TIterator >
class ThreadedIteratorRangePartitioner;
/** \class ThreadedIteratorRangePartitionerDomain
* \brief Domain type for the ThreadedIteratorRangePartitioner.
*
* Contains a Begin and End iterator.
*
* \ingroup ITKCommon
*/
template< typename TIterator >
class ThreadedIteratorRangePartitionerDomain
{
public:
typedef TIterator IteratorType;
typedef ThreadedIteratorRangePartitionerDomain Self;
ThreadedIteratorRangePartitionerDomain() {}
ThreadedIteratorRangePartitionerDomain( const IteratorType & begin, const IteratorType & end )
{
this->m_Begin = begin;
this->m_End = end;
}
ThreadedIteratorRangePartitionerDomain( const Self & rhs )
{
this->m_Begin = rhs.m_Begin;
this->m_End = rhs.m_End;
}
void operator=( const Self & rhs )
{
if ( this == & rhs )
{
return;
}
this->m_Begin = rhs.m_Begin;
this->m_End = rhs.m_End;
}
const IteratorType & Begin() const
{
return this->m_Begin;
}
const IteratorType & End() const
{
return this->m_End;
}
private:
friend class ThreadedIteratorRangePartitioner< IteratorType >;
IteratorType m_Begin;
IteratorType m_End;
};
/** \class ThreadedIteratorRangePartitioner
* \brief Partitions an iterator range for threading.
*
* \tparam TIterator The type of the iterator.
*
* The \c DomainType is defined to be an itk::ThreadedIteratorRangePartitionerDomain,
* a two component struct of interators: the first iterator, \c Begin, defines
* the start of the domain, and the second iterator, \c End, defines one element
* past the end of the domain.
*
* The class assumes that iterating through the domain will be a repeatable
* process.
*
* While this class will work for most containers that use iterators, indexed
* containers such as std::vector or Array will be partitioned much more efficiently
* with a ThreadedIndexedContainerPartitioner.
*
* This class is typically used as a template argument to a DomainThreader.
*
* \sa ThreadedDomainPartitioner
* \sa DomainThreader
* \sa ThreadedIndexedContainerPartitioner
* \ingroup ITKCommon
*/
template< typename TIterator >
class ThreadedIteratorRangePartitioner
: public ThreadedDomainPartitioner< ThreadedIteratorRangePartitionerDomain< TIterator > >
{
public:
/** Standard class typedefs. */
typedef ThreadedIteratorRangePartitioner Self;
typedef ThreadedDomainPartitioner< ThreadedIteratorRangePartitionerDomain< TIterator > > Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(ThreadedIteratorRangePartitioner, ThreadedDomainPartitioner);
/** Type for convenience of base class methods */
typedef typename Superclass::DomainType DomainType;
typedef TIterator IteratorType;
/** Split the domain \c completeDomain into up to \c requestedTotal
* non-overlapping subdomains, setting subdomain number \c threadId as
* \c subDomain and returning the total number of subdomains actually available.
*
* This method should be called repeatedly for each value of \c threadId, from 0 up
* to the return value (which is always less than or equal to \c requestedTotal).
*
* It is an error for \c completeDomain to be zero-length.
* If \c threadId is greater than the return value, the contents of
* \c subDomain are undefined.
*/
virtual
ThreadIdType PartitionDomain(const ThreadIdType threadId,
const ThreadIdType requestedTotal,
const DomainType& completeDomain,
DomainType& subDomain) const;
protected:
ThreadedIteratorRangePartitioner();
virtual ~ThreadedIteratorRangePartitioner();
private:
ThreadedIteratorRangePartitioner(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkThreadedIteratorRangePartitioner.hxx"
#endif
#endif
|