HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
TokenMap.h
Go to the documentation of this file.
1 //-*****************************************************************************
2 //
3 // Copyright (c) 2009-2015,
4 // Sony Pictures Imageworks Inc. and
5 // Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.
6 //
7 // All rights reserved.
8 //
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are
11 // met:
12 // * Redistributions of source code must retain the above copyright
13 // notice, this list of conditions and the following disclaimer.
14 // * Redistributions in binary form must reproduce the above
15 // copyright notice, this list of conditions and the following disclaimer
16 // in the documentation and/or other materials provided with the
17 // distribution.
18 // * Neither the name of Industrial Light & Magic nor the names of
19 // its contributors may be used to endorse or promote products derived
20 // from this software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 //
34 //-*****************************************************************************
35 
36 //-*****************************************************************************
37 //! \file Alembic/Util/TokenMap.h
38 //! \brief The header file containing the class definition for
39 //! the \ref Alembic::Util::TokenMap class
40 //-*****************************************************************************
41 #ifndef _Alembic_Util_TokenMap_h_
42 #define _Alembic_Util_TokenMap_h_
43 
44 #include <Alembic/Util/Export.h>
45 #include <Alembic/Util/Exception.h>
47 
48 namespace Alembic {
49 namespace Util {
50 namespace ALEMBIC_VERSION_NS {
51 
52 //-*****************************************************************************
53 // TOKEN MAP
54 //
55 //! \brief A wrapper around std::map that serializes and deserializes the map
56 //! into a doubly-tokenized string, usually of the form
57 //! token=value;token=value;token=value;
58 //-*****************************************************************************
59 
61 {
62 public:
63  //-*************************************************************************
64  // TYPEDEFS
65  //-*************************************************************************
66  //! The map_type is std::map<std::string,std::string>
67  //! ...
68  typedef std::map<std::string,std::string> map_type;
69 
70  //! key_type promoted from map_type::key_type, which is std::string
71  //! ...
72  typedef map_type::key_type key_type;
73 
74  //! data_type promoted from map_type::data_type, which is std::string
75  //! ...
76  // CJH: Not defined? typedef map_type::data_type data_type;
78 
79  //! value_type promoted from map_type::value_type, which is
80  //! std::pair<std::string, std::string>
82 
83  //! iterator promoted from map_type::iterator
84  //! ...
85  typedef map_type::iterator iterator;
86 
87  //! const_iterator promoted from map_type::iterator
88  //! ...
89  typedef map_type::const_iterator const_iterator;
90 
91  //! reverse_iterator promoted from map_type::reverse_iterator
92  //! ...
93  typedef map_type::reverse_iterator reverse_iterator;
94 
95  //! const_reverse_iterator promoted from map_type::const_reverse_iterator
96  //! ...
97  typedef map_type::const_reverse_iterator const_reverse_iterator;
98 
99  //! reference promoted from map_type::reference
100  //! ...
101  typedef map_type::reference reference;
102 
103  //! const_reference promoted from map_type::const_reference
104  //! ...
105  typedef map_type::const_reference const_reference;
106 
107  //-*************************************************************************
108  // CONSTRUCTORS
109  //-*************************************************************************
110  //! \brief Default constructor
111  //! Map is initialized with no entries. Values can be added using
112  //! The \ref set and \ref setUnique member functions
113  TokenMap() {}
114 
115  //-*************************************************************************
116  //! \brief Explicit constructor
117  //! Map is initialized from given string, using the delimiter scheme
118  //! as presented. If the 'unique' bool is 'true', it will use
119  //! the \ref setUnique function, obeying the 'quiet' bool accordingly.
120  //! Otherwise it will use the \ref set function.
121  explicit TokenMap( const std::string &config,
122  char pairSeparator = ';',
123  char assignSeparator = '=',
124  bool unique = false,
125  bool quiet = true )
126  {
127  if ( unique )
128  {
129  setUnique( config, pairSeparator, assignSeparator, quiet );
130  }
131  else
132  {
133  set( config, pairSeparator, assignSeparator );
134  }
135  }
136 
137  //-*************************************************************************
138  //! Using default copy constructor
139  //! ...
140 
141  //-*************************************************************************
142  //! Using default assignment operator.
143  //! ...
144 
145  //-*************************************************************************
146  // SET
147  //! \brief This function sets the token/value pairs in the map by
148  //! deserializing them from a doubly-delimited string.
149  //!
150  //! \details The delimiter scheme defaults to:
151  //! "token=value;token=value;token=value" but may be overridden
152  //! using the optional separator arguments. Values are added to the
153  //! map one-by-one, overwriting any values that were there before.
154  //! To avoid overwriting, use the \ref setUnique function, which can
155  //! silently or rigidly deal with conflicts
156  void set( const std::string &config,
157  char pairSeparator = ';',
158  char assignSeparator = '=' );
159 
160  //-*************************************************************************
161  // SET UNIQUE
162  //! \brief This function sets only unique (not already stored) token/value
163  //! pairs by deserializing them from a doubly-delimited string.
164  //!
165  //! \details The delimiter scheme and rules are the same as \ref set ,
166  //! the main difference here is that the class will not overwrite
167  //! values that already exist. If the function is called with
168  //! the default value of 'true' for the 'quiet' parameter, it will
169  //! simply not write those values. Otherwise, it will throw a
170  //! \ref Alembic::Util::Exception
171  void setUnique( const std::string &config,
172  char pairSeparator = ';',
173  char assignSeparator = '=',
174  bool quiet = true );
175 
176 
177  //-*************************************************************************
178  // GET
179  //! \brief This function turns the map back into a doubly-tokenized string.
180  //!
181  //! \details The passed delimiters are used to delimit the string, and
182  //! they have default values. Checking is optionally performed
183  //! (based on the 'check' bool) to make sure neither the tokens nor
184  //! values contain the delimiter characters, and an
185  //! \ref Alembic::Util::Exception is thrown if a conflict is detected.
186  std::string get( char pairSeparator = ';',
187  char assignSeparator = '=',
188  bool check = false ) const;
189 
190  //-*************************************************************************
191  // CLEAR THE MAP
192  //-*************************************************************************
193  void clear() { m_map.clear(); }
194 
195  //-*************************************************************************
196  // INDIVIDUAL TOKEN ACCESS
197  //-*************************************************************************
198 
199  //! \brief This function returns the number of pairs.
200  //! ...
201  size_t size() const { return m_map.size(); }
202 
203  //! \brief This function returns whether the map contains an entry for
204  //! a particular token.
205  bool tokenExists( const std::string &token ) const
206  {
207  return ( m_map.count( token ) > 0 );
208  }
209 
210  //! \brief This function returns the string value associated with a
211  //! particular token, or the empty string "" if the map does not
212  //! contain this token-value pair.
213  std::string value( const std::string &token ) const
214  {
215  const_iterator fiter = m_map.find( token );
216  if ( fiter != m_map.end() )
217  {
218  return (*fiter).second;
219  }
220  else
221  {
222  return "";
223  }
224  }
225 
226  //! \brief This function is a shorthand for \ref value
227  //! It will not return a modifiable entry. To modify,
228  //! \ref setValue must be used.
229  std::string operator[]( const std::string &token ) const
230  {
231  return value( token );
232  }
233 
234  //! \brief This function sets the value of a token. It will either
235  //! add a new token-value pair if the map does not already contain
236  //! this token, or it will overwrite the value for this token if
237  //! it already exists. You can use the \ref tokenExists function
238  //! to manage uniqueness guarantees.
239  void setValue( const std::string &keyStr,
240  const std::string &valueStr )
241  {
242  m_map[keyStr] = valueStr;
243  }
244 
245  //-*************************************************************************
246  // ITERATION
247  //-*************************************************************************
248 
249  //! \brief same as std::map begin
250  //! Returns an \ref iterator corresponding to the beginning of the map
251  //! or the end of the map if the map is empty.
252  iterator begin() { return m_map.begin(); }
253 
254  //! \brief same as std::map begin const
255  //! Returns a \ref const_iterator corresponding to the beginning of the
256  //! map or the end of the map if the map is empty.
257  const_iterator begin() const { return m_map.begin(); }
258 
259  //! \brief same as std::map end
260  //! Returns an \ref iterator corresponding to the end of the map.
261  iterator end() { return m_map.end(); }
262 
263  //! \brief same as std::map end const
264  //! Returns an \ref const_iterator corresponding to the end of the map.
265  const_iterator end() const { return m_map.end(); }
266 
267  //-*************************************************************************
268  // REVERSE ITERATION
269  //-*************************************************************************
270 
271  //! \brief same as std::map rbegin
272  //! Returns an \ref reverse_iterator corresponding to the
273  //! reverse_beginning of the map or the reverse_end of the map
274  //! if the map is empty.
275  reverse_iterator rbegin() { return m_map.rbegin(); }
276 
277  //! \brief same as std::map rbegin const
278  //! Returns a \ref const_reverse_iterator corresponding to the beginning
279  //! of the map or the end of the map if the map is empty.
280  const_reverse_iterator rbegin() const { return m_map.rbegin(); }
281 
282  //! \brief same as std::map rend
283  //! Returns an \ref reverse_iterator corresponding to the
284  //! reverse end of the map.
285  reverse_iterator rend() { return m_map.rend(); }
286 
287  //! \brief same as std::map rend const
288  //! Returns an \ref const_reverse_iterator corresponding to the end
289  //! of the map.
290  const_reverse_iterator rend() const { return m_map.rend(); }
291 
292  //-*************************************************************************
293  // COMPARISON
294  //-*************************************************************************
295 
296  //! Return an exact match
297  //! ...
298  bool exactMatch( const TokenMap &iOther ) const
299  {
300  return m_map == iOther.m_map;
301  }
302 
303 protected:
305 };
306 
307 //-*****************************************************************************
308 inline bool operator==( const TokenMap &iA, const TokenMap &iB )
309 {
310  return iA.exactMatch( iB );
311 }
312 
313 } // End namespace ALEMBIC_VERSION_NS
314 
315 using namespace ALEMBIC_VERSION_NS;
316 
317 } // End namespace Util
318 } // End namespace Alembic
319 
320 #endif
TokenMap()
Default constructor Map is initialized with no entries. Values can be added using The set and setUniq...
Definition: TokenMap.h:113
const_reverse_iterator rend() const
same as std::map rend const Returns an const_reverse_iterator corresponding to the end of the map...
Definition: TokenMap.h:290
reverse_iterator rbegin()
same as std::map rbegin Returns an reverse_iterator corresponding to the reverse_beginning of the map...
Definition: TokenMap.h:275
void setValue(const std::string &keyStr, const std::string &valueStr)
This function sets the value of a token. It will either add a new token-value pair if the map does no...
Definition: TokenMap.h:239
map_type::const_iterator const_iterator
Definition: TokenMap.h:89
GLsizei const GLchar *const * string
Definition: glcorearb.h:813
bool tokenExists(const std::string &token) const
This function returns whether the map contains an entry for a particular token.
Definition: TokenMap.h:205
size_t size() const
This function returns the number of pairs. ...
Definition: TokenMap.h:201
map_type::const_reference const_reference
Definition: TokenMap.h:105
uint64 value_type
Definition: GA_PrimCompat.h:29
iterator begin()
same as std::map begin Returns an iterator corresponding to the beginning of the map or the end of th...
Definition: TokenMap.h:252
A wrapper around std::map that serializes and deserializes the map into a doubly-tokenized string...
Definition: TokenMap.h:60
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
iterator end()
same as std::map end Returns an iterator corresponding to the end of the map.
Definition: TokenMap.h:261
const_iterator begin() const
same as std::map begin const Returns a const_iterator corresponding to the beginning of the map or th...
Definition: TokenMap.h:257
Header file containing class definition for class Alembic::Util::Exception.
map_type::const_reverse_iterator const_reverse_iterator
Definition: TokenMap.h:97
TokenMap(const std::string &config, char pairSeparator= ';', char assignSeparator= '=', bool unique=false, bool quiet=true)
Explicit constructor Map is initialized from given string, using the delimiter scheme as presented...
Definition: TokenMap.h:121
const_iterator end() const
same as std::map end const Returns an const_iterator corresponding to the end of the map...
Definition: TokenMap.h:265
map_type::reverse_iterator reverse_iterator
Definition: TokenMap.h:93
bool exactMatch(const TokenMap &iOther) const
Definition: TokenMap.h:298
GLsizei const GLfloat * value
Definition: glcorearb.h:823
std::string value(const std::string &token) const
This function returns the string value associated with a particular token, or the empty string "" if ...
Definition: TokenMap.h:213
reverse_iterator rend()
same as std::map rend Returns an reverse_iterator corresponding to the reverse end of the map...
Definition: TokenMap.h:285
std::string operator[](const std::string &token) const
This function is a shorthand for value It will not return a modifiable entry. To modify, setValue must be used.
Definition: TokenMap.h:229
const_reverse_iterator rbegin() const
same as std::map rbegin const Returns a const_reverse_iterator corresponding to the beginning of the ...
Definition: TokenMap.h:280
std::map< std::string, std::string > map_type
Definition: TokenMap.h:68
#define ALEMBIC_EXPORT
Definition: Export.h:51
#define ALEMBIC_VERSION_NS
Definition: Foundation.h:104