NeXus  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
NeXusStream.cpp
Go to the documentation of this file.
1 //
2 // NeXus - Neutron & X-ray Common Data Format
3 //
4 // $Id: Makefile.am 598 2005-08-19 16:19:15Z faa59 $
5 //
6 // IOStream like interface to NeXus C++ Bindings
7 //
8 // Copyright (C) 2008 Freddie Akeroyd, STFC ISIS facility
9 //
10 // This library is free software; you can redistribute it and/or
11 // modify it under the terms of the GNU Lesser General Public
12 // License as published by the Free Software Foundation; either
13 // version 2 of the License, or (at your option) any later version.
14 //
15 // This library is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 // Lesser General Public License for more details.
19 //
20 // You should have received a copy of the GNU Lesser General Public
21 // License along with this library; if not, write to the Free
22 // Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 // MA 02111-1307 USA
24 //
25 // For further information, see http://www.nexusformat.org/
26 //
27 
29 // Repository Location $HeadURL: http://svn.nexusformat.org/code/tags/4.3.0/bindings/cpp/NeXusStream.cpp $
30 // Revision of last commit $LastChangedRevision: 1259 $
31 // Date of last commit $LastChangedDate: 2009-05-08 20:29:28 +0100 (Fri, 08 May 2009) $
32 // Last changed by $LastChangedBy: Freddie Akeroyd $
34 
43 #include <iostream>
44 #include "napiconfig.h"
45 #include "NeXusStream.hpp"
46 #include "NeXusException.hpp"
47 namespace NeXus {
48 namespace Stream {
49 
50 HolderBase::HolderBase(const std::string& name) : m_name(name)
51 {
52 }
53 
54 void HolderBase::setName(const std::string& name)
55 {
56  m_name = name;
57 }
58 
59 template<typename NumT>
60 AttrHolder<NumT>::AttrHolder(const std::string& name, NumT& value) : HolderBase(name), m_c_value(NULL), m_value(&value)
61 {
62 }
63 
64 template<typename NumT>
65 AttrHolder<NumT>::AttrHolder(const std::string& name, const NumT& value) : HolderBase(name), m_c_value(&value), m_value(NULL)
66 {
67 }
68 
69 template<typename NumT>
70 AttrHolder<NumT>::AttrHolder(NumT& value) : HolderBase(""), m_c_value(NULL), m_value(&value)
71 {
72 }
73 
74 template<typename NumT>
75 AttrHolder<NumT>::AttrHolder(const NumT& value) : HolderBase(""), m_c_value(&value), m_value(NULL)
76 {
77 }
78 
79 template<typename NumT>
81 {
82  return NeXus::getType<NumT>();
83 }
84 
85 template<>
87 {
88  return NeXus::getType<char>();
89 }
90 
91 template<>
93 {
94  if (m_value != NULL)
95  {
96  nf.getAttr(m_name, *m_value);
97  }
98  else
99  {
100  throw Exception("AttrHolder<NumT>::readFromFile - not able to read into a constant");
101  }
102 }
103 
104 template<typename NumT>
106 {
107  if (m_value != NULL)
108  {
109  nf.getAttr(m_name, *m_value);
110  }
111  else
112  {
113  throw Exception("AttrHolder<NumT>::readFromFile - not able to read into a constant");
114  }
115 }
116 
117 template<typename NumT>
119 {
120  if (m_value != NULL)
121  {
122  nf.putAttr(m_name, *m_value);
123  }
124  else if (m_c_value != NULL)
125  {
126  nf.putAttr(m_name, *m_c_value);
127  }
128  else
129  {
130  throw Exception("AttrHolder<NumT>::writeToFile - no value to write");
131  }
132 }
133 
134 
135 template<typename NumT>
137 {
138  if (m_value != NULL)
139  {
140  nf.openData(m_name);
141  nf.getData(*m_value);
142  nf.closeData();
143  }
144  else if (m_c_value != NULL)
145  {
146  throw Exception("DataHolder<NumT>::readFromFile - not able to read into a constant");
147  }
148  else
149  {
150  nf.openData(m_name);
151  }
152 }
153 
154 template<typename NumT>
156 {
157  if (m_value != NULL)
158  {
159  nf.writeData(m_name, *m_value);
160  }
161  else if (m_c_value != NULL)
162  {
163  nf.writeData(m_name, *m_c_value);
164  }
165  else
166  {
167  throw Exception("DataHolder<NumT>::writeToFile - no value to write");
168  }
169 }
170 
171 template<typename NumT>
172 DataHolder<NumT>::DataHolder(const std::string& name, std::vector<NumT>& value) : HolderBase(name), m_c_value(NULL), m_value(&value)
173 {
174 }
175 
176 template<typename NumT>
177 DataHolder<NumT>::DataHolder(const std::string& name) : HolderBase(name), m_c_value(NULL), m_value(NULL)
178 {
179 }
180 
181 template<typename NumT>
182 DataHolder<NumT>::DataHolder(const std::string& name, const std::vector<NumT>& value) : HolderBase(name), m_c_value(&value), m_value(NULL)
183 {
184 }
185 
186 template<typename NumT>
187 DataHolder<NumT>::DataHolder(std::vector<NumT>& value) : HolderBase(""), m_c_value(NULL), m_value(&value)
188 {
189 }
190 
191 template<typename NumT>
192 DataHolder<NumT>::DataHolder(const std::vector<NumT>& value) : HolderBase(""), m_c_value(&value), m_value(NULL)
193 {
194 }
195 
196 template class NXDLL_EXPORT AttrHolder<double>;
197 template class NXDLL_EXPORT AttrHolder<int>;
199 
200 template class NXDLL_EXPORT DataHolder<double>;
201 template class NXDLL_EXPORT DataHolder<int>;
202 template class NXDLL_EXPORT DataHolder<char>;
203 
204 void Data::readFromFile(File& nf) const
205 {
206  m_holder->readFromFile(nf);
207  if (m_attr.size() > 0)
208  {
209  nf.openData(m_holder->getName());
211  nf.closeData();
212  }
213 }
214 
215 void Data::writeToFile(File& nf) const
216 {
217  m_holder->writeToFile(nf);
218  if (m_attr.size() > 0)
219  {
220  nf.openData(m_holder->getName());
222  nf.closeData();
223  }
224 }
225 
227 {
228  obj.writeToFile(nf);
229  return nf;
230 }
231 
233 {
234  obj.readFromFile(nf);
235  return nf;
236 }
237 
239 {
240  switch(sm)
241  {
242  case Close:
243  if (nf.isDataSetOpen())
244  {
245  nf.closeData();
246  }
247  else
248  {
249  nf.closeGroup();
250  }
251  break;
252 
253  default:
254  break;
255  }
256  return nf;
257 }
258 
260 {
261  switch(sm)
262  {
263  case Close:
264  if (nf.isDataSetOpen())
265  {
266  nf.closeData();
267  }
268  else
269  {
270  nf.closeGroup();
271  }
272  break;
273 
274  default:
275  break;
276  }
277  return nf;
278 }
279 
280 } // Stream
281 } // NeXus