HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PropertyHeader.h
Go to the documentation of this file.
1 //-*****************************************************************************
2 //
3 // Copyright (c) 2009-2011,
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 Sony Pictures Imageworks, nor
19 // Industrial Light & Magic, nor the names of their contributors may be used
20 // to endorse or promote products derived from this software without specific
21 // prior written permission.
22 //
23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 //
35 //-*****************************************************************************
36 
37 #ifndef Alembic_AbcCoreAbstract_PropertyHeader_h
38 #define Alembic_AbcCoreAbstract_PropertyHeader_h
39 
44 
45 namespace Alembic {
46 namespace AbcCoreAbstract {
47 namespace ALEMBIC_VERSION_NS {
48 
49 //-*****************************************************************************
50 //! In Alembic, Objects may have three distinct types of abstract properties.
51 //! Any fancy type-specific properties are ultimately and instance of one
52 //! of these three types of properties, identified here by an enum.
53 //! "Simple" properties are simply "non-compound" properties -
54 //! the SimpleProperty classes are simply common base classes for
55 //! Scalar and Array Properties.
57 {
58 
59  //! Compound Properties are groups of other properties, with their own
60  //! unique name and set of MetaData. All objects have a single root
61  //! compound property as the base of their property description.
63 
64  //! Scalar Properties represent Rank-0 properties, which contain a
65  //! single element value for any given time sample.
67 
68  //! Array Properties represent Rank-N properties, which contain an
69  //! array of values for any given time sample. Array properties may have
70  //! any rank of 1 or higher, but will most often be ranks 1, 2, 3.
72 };
73 
74 //-*****************************************************************************
75 //! The PropertyHeader is a collection of MetaData which helps define a
76 //! Property. It also acts as a key for getting an instance of a property
77 //! from a CompoundProperty.
79 {
80 public:
81  //! Default constructor creates an invalid property.
82  //! The propertyType is set to Scalar, but the dataType will be set
83  //! to its default value of kUnknownPOD[1]
85  : m_name(),
86  m_propertyType( kScalarProperty ),
87  m_metaData(),
88  m_dataType(),
89  m_timeSampling() {}
90 
91  //! Construct a compound property header.
92  //! Just give a name and metadata, the rest is redundant or unused.
93  explicit PropertyHeader( const std::string &iName,
94  const MetaData &iMetaData )
95  : m_name( iName ),
96  m_propertyType( kCompoundProperty ),
97  m_metaData( iMetaData ),
98  m_dataType(),
99  m_timeSampling() {}
100 
101  //! Construct a simple property header.
102  //! Use this for array or scalar properties.
104  PropertyType iPropType,
105  const MetaData &iMetaData,
106  const DataType &iDataType,
107  const TimeSamplingPtr & iTsamp )
108  : m_name( iName ),
109  m_propertyType( iPropType ),
110  m_metaData( iMetaData ),
111  m_dataType( iDataType ),
112  m_timeSampling( iTsamp ) {}
113 
114  //! Copy constructor
115  //! ...
117  : m_name( iCopy.m_name ),
118  m_propertyType( iCopy.m_propertyType ),
119  m_metaData( iCopy.m_metaData ),
120  m_dataType( iCopy.m_dataType ),
121  m_timeSampling( iCopy.m_timeSampling ) {}
122 
123  //! Assignment operator
124  //! ...
126  {
127  m_name = iCopy.m_name;
128  m_propertyType = iCopy.m_propertyType;
129  m_metaData = iCopy.m_metaData;
130  m_dataType = iCopy.m_dataType;
131  m_timeSampling = iCopy.m_timeSampling;
132  return *this;
133  }
134 
135  //! All properties have a name, which is unique amongst its siblings.
136  //! ...
137  const std::string &getName() const { return m_name; }
138 
139  void setName( const std::string &iName ) { m_name = iName; }
140 
141  //! All properties have a type, which is the enum defined above.
142  //! ...
143  PropertyType getPropertyType() const { return m_propertyType; }
144 
145  void setPropertyType( PropertyType iPtyp ) { m_propertyType = iPtyp; }
146 
147  //! Convenience to return whether the property is scalar.
148  //! Same as getPropertyType() == kScalarProperty
149  bool isScalar() const { return m_propertyType == kScalarProperty; }
150 
151  //! Convenience to return whether the property is array.
152  //! Same as getPropertyType() == kArrayProperty
153  bool isArray() const { return m_propertyType == kArrayProperty; }
154 
155  //! Convenience to return whether the property is compound.
156  //! Same as getPropertyType() == kCompoundProperty
157  bool isCompound() const { return m_propertyType == kCompoundProperty; }
158 
159  //! Convenience to return whether the property is simple (non-compound)
160  //! Same as getPropertyType() != kCompoundProperty
161  bool isSimple() const { return !isCompound(); }
162 
163  //! All properties have metadata.
164  //! ...
165  const MetaData &getMetaData() const { return m_metaData; }
166 
167  void setMetaData( const MetaData &iMetaData ) { m_metaData = iMetaData; }
168 
169  //! Non-compound properties have a data type.
170  //! If this is called for a Compound Property (basically, one which
171  //! returns kCompoundProperty from getType() above)
172  //! it will throw an exception.
173  const DataType &getDataType() const { return m_dataType; }
174 
175  void setDataType( const DataType &iDataType ) { m_dataType = iDataType; }
176 
177  //! Non-compound properties have time sampling
178  //! If this is called for a Compound Property (basically, one which
179  //! returns kCompoundProperty from getType() above)
180  //! it will throw an exception.
182  { return m_timeSampling; }
183 
184  void setTimeSampling( const TimeSamplingPtr &iTsamp )
185  { m_timeSampling = iTsamp; }
186 
187 private:
188  std::string m_name;
189  PropertyType m_propertyType;
190  MetaData m_metaData;
191  DataType m_dataType;
192  TimeSamplingPtr m_timeSampling;
193 };
194 
195 } // End namespace ALEMBIC_VERSION_NS
196 
197 using namespace ALEMBIC_VERSION_NS;
198 
199 } // End namespace AbcCoreAbstract
200 } // End namespace Alembic
201 
202 #endif
GLsizei const GLchar *const * string
Definition: glcorearb.h:813
PropertyHeader & operator=(const PropertyHeader &iCopy)
PropertyHeader(const std::string &iName, const MetaData &iMetaData)
Alembic::Util::shared_ptr< TimeSampling > TimeSamplingPtr
Definition: TimeSampling.h:137
PropertyHeader(const std::string &iName, PropertyType iPropType, const MetaData &iMetaData, const DataType &iDataType, const TimeSamplingPtr &iTsamp)
#define ALEMBIC_VERSION_NS
Definition: Foundation.h:105