extd Namespace Reference

Namespaces
namespace	impl

Functions
template<typename T >
T	clamp (T value, T low, T high)
template<typename T >
T	roundUp (T number, T multiple)
template<typename T >
T	interpolate (T a, T b, T weight)
template<class TInputIterator , class T >
bool	contains (TInputIterator first, TInputIterator last, const T &value)
template<class TContainer , class T >
bool	contains (const TContainer &container, const T &value)
template<class T >
bool	contains (const std::set< T > &container, const T &value)
template<class T , class Predicate , typename ... Args>
void	filter (std::vector< T, Args... > &source, Predicate pred)
template<class TContainer , class Predicate , typename ... Args>
void	filter (TContainer &source, Predicate pred)
template<typename TLookUpTable >
impl::LUTFilter< TLookUpTable, impl::LUTStrategy::ByValue >	byValue (const TLookUpTable &lookUpTable)
template<typename TLookUpTable >
impl::LUTFilter< TLookUpTable, impl::LUTStrategy::ByPosition >	byPosition (const TLookUpTable &lookUpTable)
template<class TContainer >
TContainer::value_type	maxOf (const TContainer &container)
template<class TSource , class TDestination >
void	copy (const TSource &source, TDestination &destination)
template<class TIterator , typename TDistance >
TIterator	advanced (TIterator source, TDistance distance)
template<class TIterator , class Predicate >
std::iterator_traits< TIterator >::difference_type	advanceWhile (TIterator &it, const TIterator &end, Predicate pred)
template<class TIterator , class Predicate >
TIterator::difference_type	advanceWhile (TIterator &it, const TIterator &end, Predicate pred)

Function Documentation

advanced()

template<class TIterator , typename TDistance >

TIterator extd::advanced	(	TIterator	source,
		TDistance	distance
	)

                                                         {
    std::advance(source, static_cast<typename std::iterator_traits<TIterator>::difference_type>(distance));
    return source;
}

Referenced by dna::LODMapping::cleanupIndices(), dnac::LODMapping::cleanupIndices(), dna::WriterImpl< TWriterBase >::deleteJointGroup(), dnac::WriterImpl< TWriterBase >::deleteJointGroup(), dna::WriterImpl< TWriterBase >::deleteMesh(), dnac::WriterImpl< TWriterBase >::deleteMesh(), dna::LODMapping::getIndices(), and dnac::LODMapping::getIndices().

advanceWhile() [1/2]

template<class TIterator , class Predicate >

std::iterator_traits< TIterator >::difference_type extd::advanceWhile	(	TIterator &	it,
		const TIterator &	end,
		Predicate	pred
	)

                                                                                                                        {
    const auto start = it;
    while (it != end && pred(*it)) {
        ++it;
    }
    return std::distance(start, it);
}

advanceWhile() [2/2]

template<class TIterator , class Predicate >

TIterator::difference_type extd::advanceWhile	(	TIterator &	it,
		const TIterator &	end,
		Predicate	pred
	)

                                                                                                    {
    const auto start = it;
    while (it != end && pred(*it)) {
        ++it;
    }
    return std::distance(start, it);
}

byPosition()

template<typename TLookUpTable >

impl::LUTFilter< TLookUpTable, impl::LUTStrategy::ByPosition > extd::byPosition ( const TLookUpTable &  lookUpTable )

inline

                                                                                                          {
    return impl::LUTFilter<TLookUpTable, impl::LUTStrategy::ByPosition>{lookUpTable};
}

Referenced by dna::AnimatedMapFilter::apply(), dna::BlendShapeFilter::apply(), dna::JointFilter::apply(), dna::MeshFilter::apply(), dnac::AnimatedMapFilter::apply(), dnac::BlendShapeFilter::apply(), dnac::JointFilter::apply(), dnac::MeshFilter::apply(), dna::LODConstraint::applyTo(), and dnac::LODConstraint::applyTo().

byValue()

template<typename TLookUpTable >

impl::LUTFilter< TLookUpTable, impl::LUTStrategy::ByValue > extd::byValue ( const TLookUpTable &  lookUpTable )

inline

                                                                                                    {
    return impl::LUTFilter<TLookUpTable, impl::LUTStrategy::ByValue>{lookUpTable};
}

clamp()

template<typename T >

T extd::clamp ( T  value, T  low, T  high  )

inline

                                       {
    return std::min(std::max(value, low), high);
}

contains() [1/3]

template<class T >

bool extd::contains ( const std::set< T > &  container, const T &  value  )

inline

                                                                 {
    return container.find(value) != container.end();
}

contains() [2/3]

template<class TContainer , class T >

bool extd::contains ( const TContainer &  container, const T &  value  )

inline

                                                                  {
    return contains(std::begin(container), std::end(container), value);
}

References contains().

contains() [3/3]

template<class TInputIterator , class T >

bool extd::contains ( TInputIterator  first, TInputIterator  last, const T &  value  )

inline

                                                                                {
    return std::find(first, last, value) != last;
}

Referenced by dna::BlendShapeFilter::apply(), dna::MeshFilter::apply(), dnac::BlendShapeFilter::apply(), dnac::MeshFilter::apply(), contains(), extd::impl::LUTFilter< TLUT, Strategy >::operator()(), dna::AnimatedMapFilter::passes(), dna::BlendShapeFilter::passes(), dna::JointFilter::passes(), dna::MeshFilter::passes(), dnac::AnimatedMapFilter::passes(), dnac::BlendShapeFilter::passes(), dnac::JointFilter::passes(), dnac::MeshFilter::passes(), dnac::DenormalizedData< Reader >::populateMeshBlendShapeMappingIndices(), dna::DenormalizedData< Reader >::populateMeshBlendShapeMappingIndices(), dna::remap(), dnac::remap(), dnac::DNACalibDNAReaderImpl::removeAnimatedMaps(), dnac::DNACalibDNAReaderImpl::removeBlendShapes(), dnac::DNACalibDNAReaderImpl::removeJoints(), and dnac::DNACalibDNAReaderImpl::removeMeshes().

copy()

template<class TSource , class TDestination >

void extd::copy ( const TSource &  source, TDestination &  destination  )

inline

                                                                   {
    std::copy(std::begin(source), std::end(source), std::back_inserter(destination));
}

References copy().

Referenced by terse::DynArray< T, TAllocator >::assign(), copy(), tdm::vec< L, T >::operator=(), and tdm::vec< L, T >::vec().

filter() [1/2]

template<class T , class Predicate , typename ... Args>

void extd::filter ( std::vector< T, Args... > &  source, Predicate  pred  )

inline

                                                                  {
    source.erase(std::remove_if(std::begin(source), std::end(source), [&source, &pred](const T& value) {
        const auto index = static_cast<std::size_t>(&value - &(source.front()));
        return !pred(value, index);
    }), source.end());
}

Referenced by dna::AnimatedMapFilter::apply(), dna::BlendShapeFilter::apply(), dna::JointFilter::apply(), dna::MeshFilter::apply(), dnac::AnimatedMapFilter::apply(), dnac::BlendShapeFilter::apply(), dnac::JointFilter::apply(), dnac::MeshFilter::apply(), dna::LODConstraint::applyTo(), dnac::LODConstraint::applyTo(), dna::LODConstraint::clampTo(), dnac::LODConstraint::clampTo(), dna::FilteredInputArchive::process(), and dnac::DNACalibDNAReaderImpl::removeMeshes().

filter() [2/2]

template<class TContainer , class Predicate , typename ... Args>

void extd::filter ( TContainer &  source, Predicate  pred  )

inline

                                                       {
    using value_type = typename TContainer::value_type;
    auto newEnd = std::remove_if(std::begin(source), std::end(source), [&source, &pred](const value_type& value) {
        const auto index = static_cast<std::size_t>(&value - source.data());
        return !pred(value, index);
    });
    const auto newSize = static_cast<std::size_t>(std::distance(source.begin(), newEnd));
    source.resize(newSize);
}

interpolate()

template<typename T >

T extd::interpolate ( T  a, T  b, T  weight  )

inline

                                         {
    return a * (static_cast<T>(1) - weight) + b * weight;
}

Referenced by dnac::OperationFactory::create().

maxOf()

template<class TContainer >

TContainer::value_type extd::maxOf ( const TContainer &  container )

inline

                                                                        {
    assert(!container.empty());
    using ValueType = typename TContainer::value_type;
    const auto compare = [](const ValueType& lhs, const ValueType& rhs) {
            return lhs.second < rhs.second;
        };
    const auto it = std::max_element(container.begin(), container.end(), compare);
    return (it == container.end() ? ValueType{} : *it);
}

Referenced by dna::JointFilter::maxRemappedIndex(), and dnac::JointFilter::maxRemappedIndex().

roundUp()

template<typename T >

T extd::roundUp ( T  number, T  multiple  )

inline

                                       {
    return ((number + multiple - 1) / multiple) * multiple;
}