HDK: Alembic/Abc/TypedArraySample.h Source File

00001 //-*****************************************************************************
00002 //
00003 // Copyright (c) 2009-2011,
00004 //  Sony Pictures Imageworks Inc. and
00005 //  Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.
00006 //
00007 // All rights reserved.
00008 //
00009 // Redistribution and use in source and binary forms, with or without
00010 // modification, are permitted provided that the following conditions are
00011 // met:
00012 // *       Redistributions of source code must retain the above copyright
00013 // notice, this list of conditions and the following disclaimer.
00014 // *       Redistributions in binary form must reproduce the above
00015 // copyright notice, this list of conditions and the following disclaimer
00016 // in the documentation and/or other materials provided with the
00017 // distribution.
00018 // *       Neither the name of Sony Pictures Imageworks, nor
00019 // Industrial Light & Magic, nor the names of their contributors may be used
00020 // to endorse or promote products derived from this software without specific
00021 // prior written permission.
00022 //
00023 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00024 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00025 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00026 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00027 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00028 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00029 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00030 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00031 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00032 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00033 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00034 //
00035 //-*****************************************************************************
00036 
00037 #ifndef _Alembic_Abc_TypedArraySample_h_
00038 #define _Alembic_Abc_TypedArraySample_h_
00039 
00040 #include <Alembic/Abc/Foundation.h>
00041 #include <Alembic/Abc/TypedPropertyTraits.h>
00042 
00043 namespace Alembic {
00044 namespace Abc {
00045 namespace ALEMBIC_VERSION_NS {
00046 
00047 using Alembic::Util::Dimensions;
00048 
00049 //-*****************************************************************************
00050 template <class TRAITS>
00051 class TypedArraySample : public AbcA::ArraySample
00052 {
00053 public:
00054     typedef TRAITS traits_type;
00055     typedef TypedArraySample<TRAITS> this_type;
00056     typedef typename TRAITS::value_type value_type;
00057     typedef typename std::vector<value_type> value_vector;
00058 
00059     //-*************************************************************************
00060     // Default
00061     TypedArraySample()
00062       : AbcA::ArraySample() {}
00063 
00064     //-*************************************************************************
00065     // From pointer+num or pointer+dims
00066     TypedArraySample( const value_type *iValues, size_t iNumVals )
00067       : AbcA::ArraySample( reinterpret_cast<const void *>( iValues ),
00068                            TRAITS::dataType(), Dimensions( iNumVals ) ) {}
00069 
00070     TypedArraySample( const value_type *iValues, const Dimensions &iDims )
00071       : AbcA::ArraySample( reinterpret_cast<const void *>( iValues ),
00072                            TRAITS::dataType(), iDims ) {}
00073 
00074     //-*************************************************************************
00075     // From std::vector
00076     TypedArraySample( const value_vector &iVec )
00077       : AbcA::ArraySample( reinterpret_cast<const void *>( iVec.size() > 0 ?
00078                                                            &iVec.front() :
00079                                                            NULL ),
00080                            TRAITS::dataType(), Dimensions( iVec.size() ) ) {}
00081 
00082     // This is for the case in which the data is multi-dimensional
00083     TypedArraySample( const value_vector &iVec,
00084                       const Dimensions &iDims )
00085       : AbcA::ArraySample( reinterpret_cast<const void *>( iVec.size() > 0 ?
00086                                                            &iVec.front() :
00087                                                            NULL ),
00088                            TRAITS::dataType(), iDims )
00089     {
00090         ABCA_ASSERT( iDims.numPoints() == iVec.size(),
00091                      "Invalid dimensions in TypedArraySample" );
00092     }
00093 
00094     //-*************************************************************************
00095     // COPY & ASSIGMENT
00096     //-*************************************************************************
00097 
00098     // From base copy
00099     TypedArraySample( const AbcA::ArraySample &iCopy )
00100       : AbcA::ArraySample( iCopy )
00101     {
00102         ABCA_ASSERT( iCopy.getDataType() == TRAITS::dataType(),
00103                      "Invalid DataType in TypedArraySample. Expected: "
00104                      << TRAITS::dataType()
00105                      << ", but got: " << iCopy.getDataType() );
00106     }
00107 
00108     TypedArraySample<TRAITS> operator=( const AbcA::ArraySample &iCopy )
00109     {
00110         ArraySample::operator=( iCopy );
00111 
00112         ABCA_ASSERT( iCopy.getDataType() == TRAITS::dataType(),
00113                      "Invalid DataType in TypedArraySample. Expected: "
00114                      << TRAITS::dataType()
00115                      << ", but got: " << iCopy.getDataType() );
00116 
00117         return *this;
00118     }
00119 
00120     const value_type *get() const
00121     {
00122         return reinterpret_cast<const value_type *>( getData() );
00123     }
00124 
00125     const value_type *operator->() const { return this->get(); }
00126 
00127     //-*************************************************************************
00128     const value_type &operator[]( const size_t i ) const
00129     {
00130         return this->get()[i];
00131     }
00132 
00133     //-*************************************************************************
00134     size_t size() const { return this->getDimensions().numPoints(); }
00135 
00136     //-*************************************************************************
00137     ALEMBIC_OPERATOR_BOOL( ArraySample::valid() );
00138 };
00139 
00140 #if 0
00141 //-*****************************************************************************
00142 // We need a "side-along" TypedArraySamplePtr. Taking advantage of the fact
00143 // that static-cast is valid here.
00144 template <class TRAITS>
00145 inline boost::shared_ptr<TypedArraySample<TRAITS> >
00146 AllocateTypedArraySample( const Dimensions &iDims )
00147 {
00148     typedef typename TRAITS::value_type value_type;
00149 
00150     const AbcA::DataType &dtype = TRAITS::dataType();
00151     size_t numElems = iDims.numPoints();
00152     if ( numElems > 0 )
00153     {
00154         // Allocate data
00155         value_type *data = new value_type[numElems];
00156 
00157         // Allocate typed array sample with fancy deleter
00158         boost::shared_ptr<TypedArraySample<TRAITS> >
00159             ret( new TypedArraySample<TRAITS>(
00160                      reinterpret_cast<const void *>( data ),
00161                      dtype, iDims ),
00162                  AbcA::TArrayDeleter<value_type>() );
00163         return ret;
00164     }
00165     else
00166     {
00167         boost::shared_ptr<TypedArraySample<TRAITS> >
00168             ret( new TypedArraySample<TRAITS>(
00169                      ( const void * )NULL, iDims ) );
00170         return ret;
00171     }
00172 }
00173 #endif
00174 
00175 //-*****************************************************************************
00176 // TYPEDEFS
00177 //-*****************************************************************************
00178 typedef TypedArraySample<BooleanTPTraits> BoolArraySample;
00179 typedef TypedArraySample<Uint8TPTraits> UcharArraySample;
00180 typedef TypedArraySample<Int8TPTraits> CharArraySample;
00181 typedef TypedArraySample<Uint16TPTraits> UInt16ArraySample;
00182 typedef TypedArraySample<Int16TPTraits> Int16ArraySample;
00183 typedef TypedArraySample<Uint32TPTraits> UInt32ArraySample;
00184 typedef TypedArraySample<Int32TPTraits> Int32ArraySample;
00185 typedef TypedArraySample<Uint64TPTraits> UInt64ArraySample;
00186 typedef TypedArraySample<Int64TPTraits> Int64ArraySample;
00187 typedef TypedArraySample<Float16TPTraits> HalfArraySample;
00188 typedef TypedArraySample<Float32TPTraits> FloatArraySample;
00189 typedef TypedArraySample<Float64TPTraits> DoubleArraySample;
00190 typedef TypedArraySample<StringTPTraits> StringArraySample;
00191 typedef TypedArraySample<WstringTPTraits> WstringArraySample;
00192 
00193 typedef TypedArraySample<V2sTPTraits> V2sArraySample;
00194 typedef TypedArraySample<V2iTPTraits> V2iArraySample;
00195 typedef TypedArraySample<V2fTPTraits> V2fArraySample;
00196 typedef TypedArraySample<V2dTPTraits> V2dArraySample;
00197 
00198 typedef TypedArraySample<V3sTPTraits> V3sArraySample;
00199 typedef TypedArraySample<V3iTPTraits> V3iArraySample;
00200 typedef TypedArraySample<V3fTPTraits> V3fArraySample;
00201 typedef TypedArraySample<V3dTPTraits> V3dArraySample;
00202 
00203 typedef TypedArraySample<P2sTPTraits> P2sArraySample;
00204 typedef TypedArraySample<P2iTPTraits> P2iArraySample;
00205 typedef TypedArraySample<P2fTPTraits> P2fArraySample;
00206 typedef TypedArraySample<P2dTPTraits> P2dArraySample;
00207 
00208 typedef TypedArraySample<P3sTPTraits> P3sArraySample;
00209 typedef TypedArraySample<P3iTPTraits> P3iArraySample;
00210 typedef TypedArraySample<P3fTPTraits> P3fArraySample;
00211 typedef TypedArraySample<P3dTPTraits> P3dArraySample;
00212 
00213 typedef TypedArraySample<Box3sTPTraits> Box3sArraySample;
00214 typedef TypedArraySample<Box3iTPTraits> Box3iArraySample;
00215 typedef TypedArraySample<Box3fTPTraits> Box3fArraySample;
00216 typedef TypedArraySample<Box3dTPTraits> Box3dArraySample;
00217 
00218 typedef TypedArraySample<M33fTPTraits> M33fArraySample;
00219 typedef TypedArraySample<M33dTPTraits> M33dArraySample;
00220 
00221 typedef TypedArraySample<M44fTPTraits> M44fArraySample;
00222 typedef TypedArraySample<M44dTPTraits> M44dArraySample;
00223 
00224 typedef TypedArraySample<QuatfTPTraits> QuatfArraySample;
00225 typedef TypedArraySample<QuatdTPTraits> QuatdArraySample;
00226 
00227 typedef TypedArraySample<C3hTPTraits> C3hArraySample;
00228 typedef TypedArraySample<C3fTPTraits> C3fArraySample;
00229 typedef TypedArraySample<C3cTPTraits> C3cArraySample;
00230 
00231 typedef TypedArraySample<C4hTPTraits> C4hArraySample;
00232 typedef TypedArraySample<C4fTPTraits> C4fArraySample;
00233 typedef TypedArraySample<C4cTPTraits> C4cArraySample;
00234 
00235 typedef TypedArraySample<N2fTPTraits> N2fArraySample;
00236 typedef TypedArraySample<N2dTPTraits> N2dArraySample;
00237 
00238 typedef TypedArraySample<N3fTPTraits> N3fArraySample;
00239 typedef TypedArraySample<N3dTPTraits> N3dArraySample;
00240 
00241 //-*****************************************************************************
00242 typedef boost::shared_ptr<BoolArraySample> BoolArraySamplePtr;
00243 typedef boost::shared_ptr<UcharArraySample> UcharArraySamplePtr;
00244 typedef boost::shared_ptr<CharArraySample> CharArraySamplePtr;
00245 typedef boost::shared_ptr<UInt16ArraySample> UInt16ArraySamplePtr;
00246 typedef boost::shared_ptr<Int16ArraySample> Int16ArraySamplePtr;
00247 typedef boost::shared_ptr<UInt32ArraySample> UInt32ArraySamplePtr;
00248 typedef boost::shared_ptr<Int32ArraySample> Int32ArraySamplePtr;
00249 typedef boost::shared_ptr<UInt64ArraySample> UInt64ArraySamplePtr;
00250 typedef boost::shared_ptr<Int64ArraySample> Int64ArraySamplePtr;
00251 typedef boost::shared_ptr<HalfArraySample> HalfArraySamplePtr;
00252 typedef boost::shared_ptr<FloatArraySample> FloatArraySamplePtr;
00253 typedef boost::shared_ptr<DoubleArraySample> DoubleArraySamplePtr;
00254 typedef boost::shared_ptr<StringArraySample> StringArraySamplePtr;
00255 typedef boost::shared_ptr<WstringArraySample> WstringArraySamplePtr;
00256 
00257 typedef boost::shared_ptr<V2sArraySample> V2sArraySamplePtr;
00258 typedef boost::shared_ptr<V2iArraySample> V2iArraySamplePtr;
00259 typedef boost::shared_ptr<V2fArraySample> V2fArraySamplePtr;
00260 typedef boost::shared_ptr<V2dArraySample> V2dArraySamplePtr;
00261 
00262 typedef boost::shared_ptr<V3sArraySample> V3sArraySamplePtr;
00263 typedef boost::shared_ptr<V3iArraySample> V3iArraySamplePtr;
00264 typedef boost::shared_ptr<V3fArraySample> V3fArraySamplePtr;
00265 typedef boost::shared_ptr<V3dArraySample> V3dArraySamplePtr;
00266 
00267 typedef boost::shared_ptr<P2sArraySample> P2sArraySamplePtr;
00268 typedef boost::shared_ptr<P2iArraySample> P2iArraySamplePtr;
00269 typedef boost::shared_ptr<P2fArraySample> P2fArraySamplePtr;
00270 typedef boost::shared_ptr<P2dArraySample> P2dArraySamplePtr;
00271 
00272 typedef boost::shared_ptr<P3sArraySample> P3sArraySamplePtr;
00273 typedef boost::shared_ptr<P3iArraySample> P3iArraySamplePtr;
00274 typedef boost::shared_ptr<P3fArraySample> P3fArraySamplePtr;
00275 typedef boost::shared_ptr<P3dArraySample> P3dArraySamplePtr;
00276 
00277 typedef boost::shared_ptr<Box3sArraySample> Box3sArraySamplePtr;
00278 typedef boost::shared_ptr<Box3iArraySample> Box3iArraySamplePtr;
00279 typedef boost::shared_ptr<Box3fArraySample> Box3fArraySamplePtr;
00280 typedef boost::shared_ptr<Box3dArraySample> Box3dArraySamplePtr;
00281 
00282 typedef boost::shared_ptr<M33fArraySample> M33fArraySamplePtr;
00283 typedef boost::shared_ptr<M33dArraySample> M33dArraySamplePtr;
00284 
00285 typedef boost::shared_ptr<M44fArraySample> M44fArraySamplePtr;
00286 typedef boost::shared_ptr<M44dArraySample> M44dArraySamplePtr;
00287 
00288 typedef boost::shared_ptr<QuatfArraySample> QuatfArraySamplePtr;
00289 typedef boost::shared_ptr<QuatdArraySample> QuatdArraySamplePtr;
00290 
00291 typedef boost::shared_ptr<C3hArraySample> C3hArraySamplePtr;
00292 typedef boost::shared_ptr<C3fArraySample> C3fArraySamplePtr;
00293 typedef boost::shared_ptr<C3cArraySample> C3cArraySamplePtr;
00294 
00295 typedef boost::shared_ptr<C4hArraySample> C4hArraySamplePtr;
00296 typedef boost::shared_ptr<C4fArraySample> C4fArraySamplePtr;
00297 typedef boost::shared_ptr<C4cArraySample> C4cArraySamplePtr;
00298 
00299 typedef boost::shared_ptr<N2fArraySample> N2fArraySamplePtr;
00300 typedef boost::shared_ptr<N2dArraySample> N2dArraySamplePtr;
00301 
00302 typedef boost::shared_ptr<N3fArraySample> N3fArraySamplePtr;
00303 typedef boost::shared_ptr<N3dArraySample> N3dArraySamplePtr;
00304 
00305 } // End namespace ALEMBIC_VERSION_NS
00306 
00307 using namespace ALEMBIC_VERSION_NS;
00308 
00309 } // End namespace Abc
00310 } // End namespace Alembic
00311 
00312 #endif