TWeightedFeatureWrap.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// ICF includes
#include <istd/CChangeNotifier.h>
#include <iser/CArchiveTag.h>
#include <imeas/CGeneralNumericValue.h>
 
 
namespace iipr
{
 
 
template <class BaseObject>
class TWeightedFeatureWrap:
        public imeas::CGeneralNumericValue,
        public BaseObject
{
public:
    typedef imeas::CGeneralNumericValue BaseClass;
    typedef BaseObject BaseClass2;
 
    TWeightedFeatureWrap(double weight = 1.0);
 
    double GetWeight() const;
    void SetWeight(double weight);
 
    // reimplemented (imeas::INumericValue)
    bool IsValueTypeSupported(ValueTypeId valueTypeId, bool editableOnly = false) const override;
    double GetComponentValue(ValueTypeId valueTypeId) const override;
    bool SetComponentValue(ValueTypeId valueTypeId, double value) override;
 
    // reimplemented (iser::ISerializable)
    bool Serialize(iser::IArchive& archive) override;
 
    // reimplemented (istd::IChangeable)
    bool CopyFrom(const IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS) override;
    std::unique_ptr<istd::IChangeable> CloneMe(CompatibilityMode mode = CM_WITHOUT_REFS) const override;
    bool ResetData(CompatibilityMode mode = CM_WITHOUT_REFS) override;
 
protected:
    double m_weight;
};
 
 
// public methods
 
template <class BaseObject>
TWeightedFeatureWrap<BaseObject>::TWeightedFeatureWrap(double weight)
    :m_weight(weight)
{
}
 
 
template <class BaseObject>
double TWeightedFeatureWrap<BaseObject>::GetWeight() const
{
    return m_weight;
}
 
 
template <class BaseObject>
void TWeightedFeatureWrap<BaseObject>::SetWeight(double weight)
{
    m_weight = weight;
}
 
 
// reimplemented (imeas::INumericValue)
 
template <class BaseObject>
bool TWeightedFeatureWrap<BaseObject>::IsValueTypeSupported(ValueTypeId valueTypeId, bool editableOnly) const
{
    return (valueTypeId == VTI_WEIGHT) || BaseClass::IsValueTypeSupported(valueTypeId, editableOnly);
}
 
 
template <class BaseObject>
double TWeightedFeatureWrap<BaseObject>::GetComponentValue(ValueTypeId valueTypeId) const
{
    if (valueTypeId == VTI_WEIGHT) {
        return m_weight;
    }
 
    return BaseClass::GetComponentValue(valueTypeId);
}
 
 
template <class BaseObject>
bool TWeightedFeatureWrap<BaseObject>::SetComponentValue(ValueTypeId valueTypeId, double value)
{
    if (valueTypeId == VTI_WEIGHT) {
        m_weight = value;
        return true;
    }
 
    return BaseClass::SetComponentValue(valueTypeId, value);
}
 
 
// reimplemented (iser::ISerializable)
 
template <class BaseObject>
bool TWeightedFeatureWrap<BaseObject>::Serialize(iser::IArchive& archive)
{
    iser::CArchiveTag weightTag("Weight", "Weight", iser::CArchiveTag::Type::Leaf);
 
    istd::CChangeNotifier notifier(archive.IsChanging()? this: nullptr);
 
    return  BaseClass::Serialize(archive) &&
            BaseClass2::Serialize(archive) &&
            archive.ProcessLeaf(weightTag, m_weight);
}
 
 
// reimplemented (istd::IChangeable)
 
template <class BaseObject>
bool TWeightedFeatureWrap<BaseObject>::CopyFrom(const IChangeable& object, CompatibilityMode mode)
{
    const TWeightedFeatureWrap<BaseObject>* objectPtr = dynamic_cast<const TWeightedFeatureWrap<BaseObject>*>(&object);
    if (objectPtr != nullptr) {
        m_weight = objectPtr->GetWeight();
    }
 
    return BaseObject::CopyFrom(object, mode);
}
 
 
template <class BaseObject>
std::unique_ptr<istd::IChangeable> TWeightedFeatureWrap<BaseObject>::CloneMe(CompatibilityMode mode) const
{
    std::unique_ptr<istd::IChangeable> clonePtr{new TWeightedFeatureWrap<BaseObject>()};
 
    if (clonePtr->CopyFrom(*this, mode)) {
        return clonePtr;
    }
 
    return nullptr;
}
 
 
template <class BaseObject>
bool TWeightedFeatureWrap<BaseObject>::ResetData(CompatibilityMode mode)
{
    istd::CChangeNotifier notifier(this);
 
    BaseClass::ResetData(mode);
 
    m_weight = 0;
 
    return true;
}
 
 
} // namespace iipr