ResInsight/Fwk/AppFwk/cafProjectDataModel/cafPdmXml/cafInternalPdmXmlFieldCapability.h

#pragma once

#include "cafInternalPdmXmlFieldReaderWriter.h"
#include "cafPdmProxyValueField.h"
#include "cafPdmXmlFieldHandle.h"

#include <typeinfo>

namespace caf
{
template <typename FieldType>
class PdmFieldXmlCap : public PdmXmlFieldHandle
{
public:
    // Type traits magic to check if a template argument is a vector
    template <typename T>
    struct is_vector : public std::false_type
    {
    };
    template <typename T, typename A>
    struct is_vector<std::vector<T, A>> : public std::true_type
    {
    };

    PdmFieldXmlCap( FieldType* field, bool giveOwnership )
        : PdmXmlFieldHandle( field, giveOwnership )
    {
        m_field        = field;
        m_dataTypeName = QString( "%1" ).arg( typeid( typename FieldType::FieldDataType ).name() );
    }

    // Xml Serializing
public:
    std::vector<QString> readFieldData( QXmlStreamReader&                       xmlStream,
                                        PdmObjectFactory*                       objectFactory,
                                        const std::vector<caf::PdmDeprecation>& deprecations = {} ) override;
    void                 writeFieldData( QXmlStreamWriter& xmlStream ) const override;
    bool                 resolveReferences() override;

    bool isVectorField() const override;

private:
    FieldType* m_field;
};

template <typename DataType>
class PdmPtrField;

template <typename DataType>
class PdmFieldXmlCap<PdmPtrField<DataType*>> : public PdmXmlFieldHandle
{
    typedef PdmPtrField<DataType*> FieldType;

public:
    PdmFieldXmlCap( FieldType* field, bool giveOwnership )
        : PdmXmlFieldHandle( field, giveOwnership )
    {
        m_field           = field;
        m_dataTypeName    = DataType::classKeywordStatic();
        m_referenceString = "";
    }

    // Xml Serializing
public:
    std::vector<QString> readFieldData( QXmlStreamReader&                       xmlStream,
                                        PdmObjectFactory*                       objectFactoryconst,
                                        const std::vector<caf::PdmDeprecation>& deprecations = {} ) override;
    void                 writeFieldData( QXmlStreamWriter& xmlStream ) const override;
    bool                 resolveReferences() override;
    QString              referenceString() const override;

private:
    FieldType* m_field;

    // Resolving
    QString m_referenceString;
};

template <typename DataType>
class PdmPtrArrayField;

template <typename DataType>
class PdmFieldXmlCap<PdmPtrArrayField<DataType*>> : public PdmXmlFieldHandle
{
    typedef PdmPtrArrayField<DataType*> FieldType;

public:
    PdmFieldXmlCap( FieldType* field, bool giveOwnership )
        : PdmXmlFieldHandle( field, giveOwnership )
    {
        m_field           = field;
        m_dataTypeName    = DataType::classKeywordStatic();
        m_referenceString = "";
    }

    // Xml Serializing
public:
    std::vector<QString> readFieldData( QXmlStreamReader&                       xmlStream,
                                        PdmObjectFactory*                       objectFactory,
                                        const std::vector<caf::PdmDeprecation>& deprecations = {} ) override;
    void                 writeFieldData( QXmlStreamWriter& xmlStream ) const override;
    bool                 resolveReferences() override;
    bool                 isVectorField() const override;

private:
    FieldType* m_field;

    // Resolving
    QString m_referenceString;
};

template <typename DataType>
class PdmChildField;

template <typename DataType>
class PdmFieldXmlCap<PdmChildField<DataType*>> : public PdmXmlFieldHandle
{
    typedef PdmChildField<DataType*> FieldType;

public:
    PdmFieldXmlCap( FieldType* field, bool giveOwnership )
        : PdmXmlFieldHandle( field, giveOwnership )
    {
        m_field        = field;
        m_dataTypeName = DataType::classKeywordStatic();
    }

    // Xml Serializing
public:
    std::vector<QString> readFieldData( QXmlStreamReader&                       xmlStream,
                                        PdmObjectFactory*                       objectFactory,
                                        const std::vector<caf::PdmDeprecation>& deprecations = {} ) override;
    void                 writeFieldData( QXmlStreamWriter& xmlStream ) const override;
    bool                 resolveReferences() override;

private:
    FieldType* m_field;
};

template <typename DataType>
class PdmChildArrayField;

template <typename DataType>
class PdmFieldXmlCap<PdmChildArrayField<DataType*>> : public PdmXmlFieldHandle
{
    typedef PdmChildArrayField<DataType*> FieldType;

public:
    PdmFieldXmlCap( FieldType* field, bool giveOwnership )
        : PdmXmlFieldHandle( field, giveOwnership )
    {
        m_field        = field;
        m_dataTypeName = DataType::classKeywordStatic();
    }

    // Xml Serializing
public:
    std::vector<QString> readFieldData( QXmlStreamReader&                       xmlStream,
                                        PdmObjectFactory*                       objectFactory,
                                        const std::vector<caf::PdmDeprecation>& deprecations = {} ) override;
    void                 writeFieldData( QXmlStreamWriter& xmlStream ) const override;
    bool                 resolveReferences() override;
    bool                 isVectorField() const override;

private:
    FieldType* m_field;
};

template <typename DataType>
class PdmField;

template <typename DataType>
class PdmFieldXmlCap<PdmField<std::vector<DataType>>> : public PdmXmlFieldHandle
{
    typedef PdmField<std::vector<DataType>> FieldType;

public:
    PdmFieldXmlCap( FieldType* field, bool giveOwnership )
        : PdmXmlFieldHandle( field, giveOwnership )
    {
        m_field = field;

        m_dataTypeName = QString( "%1" ).arg( typeid( DataType ).name() );
    }

    // Xml Serializing
public:
    std::vector<QString> readFieldData( QXmlStreamReader&                       xmlStream,
                                        PdmObjectFactory*                       objectFactory,
                                        const std::vector<caf::PdmDeprecation>& deprecations = {} ) override;
    void                 writeFieldData( QXmlStreamWriter& xmlStream ) const override;
    bool                 resolveReferences() override;
    bool                 isVectorField() const override;

private:
    FieldType* m_field;
};

template <typename DataType>
class PdmFieldXmlCap<PdmProxyValueField<DataType>> : public PdmXmlFieldHandle
{
    typedef PdmProxyValueField<DataType> FieldType;

public:
    PdmFieldXmlCap( FieldType* field, bool giveOwnership )
        : PdmXmlFieldHandle( field, giveOwnership )
    {
        m_field        = field;
        m_dataTypeName = QString( "%1" ).arg( typeid( DataType ).name() );

        // Proxy fields should not be serialized by default
        // If needed, this can be overridden by the user by enabling IO on the field:
        //
        //   m_proxyDoubleField.xmlCapability()->setIOWritable( true );
        //   m_proxyDoubleField.xmlCapability()->setIOReadable( true );

        disableIO();
    }

    // Xml Serializing
public:
    std::vector<QString> readFieldData( QXmlStreamReader&                       xmlStream,
                                        PdmObjectFactory*                       objectFactory,
                                        const std::vector<caf::PdmDeprecation>& deprecations = {} ) override;
    void                 writeFieldData( QXmlStreamWriter& xmlStream ) const override;
    bool                 resolveReferences() override;

    bool isVectorField() const override;

private:
    FieldType* m_field;
};

template <typename FieldType>
void addXmlCapabilityToField( FieldType* field )
{
    if ( field->template capability<PdmFieldXmlCap<FieldType>>() == NULL )
    {
        new PdmFieldXmlCap<FieldType>( field, true );
    }
}

template <typename FieldType>
void registerClassWithField( const QString& classKeyword, FieldType* field )
{
    field->setOwnerClass( classKeyword );
}

} // End of namespace caf

#include "cafInternalPdmXmlFieldCapability.inl"