1 /*=========================================================================
2  *
3  *  Copyright Insight Software Consortium
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at
8  *
9  *         http://www.apache.org/licenses/LICENSE-2.0.txt
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  *=========================================================================*/
18 #ifndef itkTreeIteratorClone_h
19 #define itkTreeIteratorClone_h
20 
21 #include "itkMacro.h"
22 #include <iostream>
23 
24 namespace itk
25 {
26 /** \class itkTreeIteratorClone
27  *  \brief itkTreeIteratorClone class
28  *  \ingroup DataRepresentation
29  *  \ingroup ITKCommon
30  */
31 template< typename TObjectType >
32 class TreeIteratorClone
33 {
34 public:
35 
36   /** Typedefs */
37   using Self = TreeIteratorClone< TObjectType >;
38   using ObjectType = TObjectType;
39 
40   /** Constructor  */
TreeIteratorClone()41   TreeIteratorClone () { m_Pointer = 0; }
42 
43   /** Copy constructor  */
TreeIteratorClone(const TreeIteratorClone<ObjectType> & p)44   TreeIteratorClone (const TreeIteratorClone< ObjectType > & p)
45   {
46     m_Pointer = nullptr;
47     if ( p.m_Pointer != nullptr )
48       {
49       m_Pointer = p.m_Pointer->Clone();
50       }
51   }
52 
53   /** Constructor to pointer p  */
TreeIteratorClone(ObjectType * p)54   TreeIteratorClone (ObjectType *p)
55   {
56     m_Pointer = 0;
57     if ( p != nullptr )
58       {
59       m_Pointer = p->Clone();
60       }
61   }
62 
63   /** Constructor to reference p  */
TreeIteratorClone(const ObjectType & p)64   TreeIteratorClone (const ObjectType & p)
65   {
66     m_Pointer = nullptr;
67     m_Pointer = const_cast< ObjectType * >( &p )->Clone();
68   }
69 
70   /** Destructor  */
~TreeIteratorClone()71   ~TreeIteratorClone ()
72   {
73     delete m_Pointer;
74     m_Pointer = nullptr;
75   }
76 
77   /** Overload operator ->  */
78   ObjectType * operator->() const { return m_Pointer; }
79 
80   /** Test if the pointer has been initialized */
IsNotNull()81   bool IsNotNull() const { return m_Pointer != 0; }
IsNull()82   bool IsNull() const { return m_Pointer == 0; }
83 
84   /** Template comparison operators. */
85   template< typename TR >
86   bool operator==(TR r) const { return ( m_Pointer == (ObjectType *)( r ) ); }
87 
88   template< typename TR >
89   bool operator!=(TR r) const { return ( m_Pointer != (ObjectType *)( r ) ); }
90 
91   /** Access function to pointer. */
GetPointer()92   ObjectType * GetPointer() const { return m_Pointer; }
93 
94   /** Comparison of pointers. Less than comparison.  */
95   bool operator<(const TreeIteratorClone & r) const { return (void *)m_Pointer < (void *)r.m_Pointer;  }
96 
97   /** Comparison of pointers. Greater than comparison.  */
98   bool operator>(const TreeIteratorClone & r) const { return (void *)m_Pointer > (void *)r.m_Pointer; }
99 
100   /** Comparison of pointers. Less than or equal to comparison.  */
101   bool operator<=(const TreeIteratorClone & r) const { return (void *)m_Pointer <= (void *)r.m_Pointer; }
102 
103   /** Comparison of pointers. Greater than or equal to comparison.  */
104   bool operator>=(const TreeIteratorClone & r) const { return (void *)m_Pointer >= (void *)r.m_Pointer; }
105 
106   /** Overload operator assignment.  */
107   TreeIteratorClone & operator=(const TreeIteratorClone & r) { return this->operator=( r.GetPointer() ); }
108 
109   /** Overload operator assignment.  */
110   TreeIteratorClone & operator=(const ObjectType *r)
111   {
112     if ( m_Pointer != r )
113       {
114       delete m_Pointer;
115       m_Pointer = nullptr;
116       if ( r != nullptr )
117         {
118         m_Pointer = const_cast< ObjectType * >( r )->Clone();
119         }
120       }
121     return *this;
122   }
123 
124   Self &
125   operator++()
126   {
127     if ( m_Pointer )
128       {
129       ++( *m_Pointer );
130       }
131     return *this;
132   }
133 
134   const Self
135   operator++(int)
136   {
137     if ( m_Pointer )
138       {
139       const Self oldValue(m_Pointer);   // create a copy of the iterator behind
140                                         // the pointer (Clone())
141       ++( *m_Pointer );
142       return oldValue;
143       }
144   }
145 
146   /** Function to print object pointed to  */
Print(std::ostream & os)147   ObjectType * Print(std::ostream & os) const
148   {
149     // This prints the object pointed to by the pointer
150     ( *m_Pointer ).Print(os);
151     return m_Pointer;
152   }
153 
154 private:
155   /** The pointer to the object referred to by this smart pointer. */
156   ObjectType *m_Pointer;
157 };
158 
159 template< typename T >
160 std::ostream & operator<<(std::ostream & os, TreeIteratorClone< T > p)
161 {
162   p.Print(os);
163   return os;
164 }
165 } // end namespace itk
166 
167 #endif
168