//-***************************************************************************** static void WriteTimeSamplingType( hid_t iGroup, const std::string &iName, const AbcA::TimeSamplingType &iTimeSamplingType ) { const std::string nameSPC = iName + ".tspc"; const std::string nameTPC = iName + ".ttpc"; const uint32_t spc = iTimeSamplingType.getNumSamplesPerCycle(); const chrono_t tpc = iTimeSamplingType.getTimePerCycle(); if ( iTimeSamplingType.isUniform() ) { // With uniform, we JUST write the time per sample assert( spc == 1 ); WriteScalar( iGroup, nameTPC, H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE, ( const void * )&tpc ); } else if ( iTimeSamplingType.isCyclic() ) { // Here we have to write SPC, and if TPC is 1.0 we don't // bother writing it. assert( spc > 1 ); assert( tpc < AbcA::TimeSamplingType::AcyclicTimePerCycle() ); WriteScalar( iGroup, nameSPC, H5T_STD_U32LE, H5T_NATIVE_UINT32, ( const void * )&spc ); if ( tpc != 1.0 ) { WriteScalar( iGroup, nameTPC, H5T_IEEE_F64LE, H5T_NATIVE_DOUBLE, ( const void * )&tpc ); } } else { assert( iTimeSamplingType.isAcyclic() ); assert( spc == AbcA::TimeSamplingType::AcyclicNumSamples() ); WriteScalar( iGroup, nameSPC, H5T_STD_U32LE, H5T_NATIVE_UINT32, ( const void * )&spc ); } }
uint8_t *ResizeAnyVector(const reflection::Schema &schema, uoffset_t newsize, const VectorOfAny *vec, uoffset_t num_elems, uoffset_t elem_size, std::vector<uint8_t> *flatbuf, const reflection::Object *root_table) { auto delta_elem = static_cast<int>(newsize) - static_cast<int>(num_elems); auto delta_bytes = delta_elem * static_cast<int>(elem_size); auto vec_start = reinterpret_cast<const uint8_t *>(vec) - flatbuf->data(); auto start = static_cast<uoffset_t>(vec_start + sizeof(uoffset_t) + elem_size * num_elems); if (delta_bytes) { if (delta_elem < 0) { // Clear elements we're throwing away, since some might remain in the // buffer. auto size_clear = -delta_elem * elem_size; memset(flatbuf->data() + start - size_clear, 0, size_clear); } ResizeContext(schema, start, delta_bytes, flatbuf, root_table); WriteScalar(flatbuf->data() + vec_start, newsize); // Length field. // Set new elements to 0.. this can be overwritten by the caller. if (delta_elem > 0) { memset(flatbuf->data() + start, 0, delta_elem * elem_size); } } return flatbuf->data() + start; }
//-***************************************************************************** void SpwImpl::copyPreviousSample( hid_t iGroup, const std::string &iSampleName, index_t iSampleIndex ) { assert( iGroup >= 0 ); assert( m_previousSample.getData() ); // Write the sample. const AbcA::DataType &dtype = m_header->getDataType(); if ( dtype.getPod() == kStringPOD ) { const std::string *strings = reinterpret_cast<const std::string *>( m_previousSample.getData() ); if ( dtype.getExtent() == 1 ) { WriteString( iGroup, iSampleName, *strings ); } else { WriteStrings( iGroup, iSampleName, dtype.getExtent(), strings ); } } else if ( dtype.getPod() == kWstringPOD ) { const std::wstring *wstrings = reinterpret_cast<const std::wstring *>( m_previousSample.getData() ); if ( dtype.getExtent() == 1 ) { WriteWstring( iGroup, iSampleName, *wstrings ); } else { WriteWstrings( iGroup, iSampleName, dtype.getExtent(), wstrings ); } } else { assert( m_fileDataType >= 0 ); assert( m_nativeDataType >= 0 ); WriteScalar( iGroup, iSampleName, m_fileDataType, m_nativeDataType, m_previousSample.getData() ); } }