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
19 #ifndef itkOptimizerParameters_hxx
20 #define itkOptimizerParameters_hxx
21
22 #include "itkOptimizerParameters.h"
23
24 namespace itk
25 {
26 /** Default contstructor */
27 template<typename TParametersValueType>
28 OptimizerParameters<TParametersValueType>
OptimizerParameters()29 ::OptimizerParameters()
30 : Array<TParametersValueType>(),
31 m_Helper(nullptr)
32 {
33 this->Initialize();
34 }
35
36 /** Copy constructor */
37 template<typename TParametersValueType>
38 OptimizerParameters<TParametersValueType>
OptimizerParameters(const OptimizerParameters & rhs)39 ::OptimizerParameters(const OptimizerParameters& rhs)
40 : Array<TParametersValueType>(rhs),
41 m_Helper(nullptr)
42 {
43 //Note: don't copy the OptimizerParametersHelper.
44 //The Array copy constructor will allocate new memory
45 //and copy the data to it. So we end up here with a generic
46 //OptimizerParameters data object even if 'rhs' points to
47 //something different.
48 this->Initialize();
49 }
50
51 /** Constructor with size */
52 template<typename TParametersValueType>
53 OptimizerParameters<TParametersValueType>
OptimizerParameters(SizeValueType dimension)54 ::OptimizerParameters(SizeValueType dimension)
55 : Array<TParametersValueType>(dimension),
56 m_Helper(nullptr)
57 {
58 this->Initialize();
59 }
60
61 /** Constructor with Array assignment */
62 template<typename TParametersValueType>
63 OptimizerParameters<TParametersValueType>
OptimizerParameters(const ArrayType & array)64 ::OptimizerParameters(const ArrayType& array)
65 : Array<TParametersValueType>(array),
66 m_Helper(nullptr)
67 {
68 this->Initialize();
69 }
70
71 template<typename TParametersValueType>
72 void
73 OptimizerParameters<TParametersValueType>
Initialize()74 ::Initialize()
75 {
76 // Set the default OptimizerParametersHelper
77 auto * helper = new OptimizerParametersHelperType;
78 // OptimizerParameters will manage this memory.
79 this->SetHelper( helper );
80 }
81
82 /** Destructor */
83 template<typename TParametersValueType>
84 OptimizerParameters<TParametersValueType>
~OptimizerParameters()85 ::~OptimizerParameters()
86 {
87 delete this->m_Helper;
88 }
89
90 template<typename TParametersValueType>
91 void
92 OptimizerParameters<TParametersValueType>
SetHelper(OptimizerParametersHelperType * helper)93 ::SetHelper( OptimizerParametersHelperType* helper )
94 {
95 delete this->m_Helper;
96 this->m_Helper = helper;
97 }
98
99 /** Copy operator for self */
100 template<typename TParametersValueType>
101 const typename OptimizerParameters<TParametersValueType>
102 ::Self &
103 OptimizerParameters<TParametersValueType>
operator =(const Self & rhs)104 ::operator=(const Self & rhs)
105 {
106 //Note: there's no need to copy the OptimizerParametersHelper.
107 // Call the superclass implementation.
108 this->ArrayType::operator=(rhs);
109 return *this;
110 }
111
112 template<typename TParametersValueType>
113 const typename OptimizerParameters<TParametersValueType>
114 ::Self &
115 OptimizerParameters<TParametersValueType>
operator =(const ArrayType & rhs)116 ::operator=(const ArrayType & rhs)
117 {
118 // Call the superclass implementation
119 this->ArrayType::operator=(rhs);
120 return *this;
121 }
122
123 template<typename TParametersValueType>
124 const typename OptimizerParameters<TParametersValueType>
125 ::Self &
126 OptimizerParameters<TParametersValueType>
operator =(const VnlVectorType & rhs)127 ::operator=(const VnlVectorType & rhs)
128 {
129 // Call the superclass implementation
130 this->ArrayType::operator=(rhs);
131 return *this;
132 }
133
134 template<typename TParametersValueType>
135 void
136 OptimizerParameters<TParametersValueType>
MoveDataPointer(TParametersValueType * pointer)137 ::MoveDataPointer( TParametersValueType * pointer )
138 {
139 if( m_Helper == nullptr )
140 {
141 itkGenericExceptionMacro("OptimizerParameters::MoveDataPointer: "
142 "m_Helper must be set.");
143 }
144 this->m_Helper->MoveDataPointer( this, pointer );
145 }
146
147 template<typename TParametersValueType>
148 void
149 OptimizerParameters<TParametersValueType>
SetParametersObject(LightObject * object)150 ::SetParametersObject( LightObject * object )
151 {
152 if( m_Helper == nullptr )
153 {
154 itkGenericExceptionMacro("OptimizerParameters::SetParameterObject: "
155 "m_Helper must be set.");
156 }
157 this->m_Helper->SetParametersObject( this, object );
158 }
159
160 }//namespace itk
161 #endif
162