ddcompare.h

Go to the documentation of this file.

 
#ifndef DDCOMPARE_H_INCLUDED
#define DDCOMPARE_H_INCLUDED
 
#include <a_util/result.h>
#include <ddl/dd/dd.h>
#include <ddl/codec/data_representation.h>
 
namespace ddl {
class DDCompare {
public:
    enum DescriptionCheckFlags {
        dcf_data_types = 0x01,        
        dcf_units = 0x02,             
        dcf_enums = 0x04,             
        dcf_structs = 0x08,           
        dcf_streams = 0x10,           
        dcf_base_units = 0x20,        
        dcf_prefixes = 0x40,          
        dcf_stream_meta_types = 0x80, 
        dcf_all = 0xFF,               
        dcf_subset = 0x0100,   
        dcf_versions = 0x0200, 
        dcf_comments = 0x0400, 
        dcf_descriptions = 0x0800, 
        dcf_header = 0x1000,       
        dcf_visualization_attributes =
            0x2000, 
        dcf_no_enum_values_check = 0x010000, 
        dcf_no_recursion =
            0x020000, 
        dcf_no_header_dates =
            0x040000, 
 
        dcf_everything = 0xFFFF 
    };

    enum ItemCheckFlags {
        icf_none = 0x00,
        icf_memory = 0x01,     
        icf_serialized = 0x02, 
        icf_names =
            0x04, 
        icf_versions =
            0x08, 
        icf_units = 0x10,        
        icf_comments = 0x20,     
        icf_descriptions = 0x40, 
        icf_subset = 0x80,       
        icf_visualizations_attributes =
            0x0100, 
        icf_no_enum_values_check = 0x0200, 
        icf_no_recursion =
            0x0400, 
        icf_everything =
            0x1FF 
    };
 
public:
    static a_util::result::Result isBinaryEqual(const std::string& type1,
                                                const std::string& desc1,
                                                const std::string& type2,
                                                const std::string& desc2,
                                                bool is_subset = true);

    static a_util::result::Result isBinaryEqual(const std::string& type1,
                                                const std::string& desc1,
                                                ddl::DataRepresentation rep1,
                                                const std::string& type2,
                                                const std::string& desc2,
                                                ddl::DataRepresentation rep2,
                                                bool is_subset = true);

    static a_util::result::Result isBinaryEqual(const std::string& type1,
                                                const dd::DataDefinition& desc1,
                                                const std::string& type2,
                                                const dd::DataDefinition& desc2,
                                                bool is_subset = true);

    static a_util::result::Result isBinaryEqual(const std::string& type1,
                                                const dd::DataDefinition& desc1,
                                                ddl::DataRepresentation rep1,
                                                const std::string& type2,
                                                const dd::DataDefinition& desc2,
                                                ddl::DataRepresentation rep2,
                                                bool is_subset = true);
 
    // main ddl entities comparisons

    static a_util::result::Result isEqualPrefix(const std::string& prefix1,
                                                const std::string& desc1,
                                                const std::string& prefix2,
                                                const std::string& desc2,
                                                uint32_t flags = icf_none);

    static a_util::result::Result isEqual(const dd::UnitPrefix& prefix1,
                                          const dd::UnitPrefix& prefix2,
                                          uint32_t flags = icf_none);

    static a_util::result::Result isEqualUnit(const std::string& unit1,
                                              const std::string& desc1,
                                              const std::string& unit2,
                                              const std::string& desc2,
                                              uint32_t flags = icf_none);

    static a_util::result::Result isEqual(const dd::Unit& unit1,
                                          const dd::DataDefinition& source_dd_of_unit1,
                                          const dd::Unit& unit2,
                                          const dd::DataDefinition& source_dd_of_unit2,
                                          uint32_t flags = icf_none);

    static a_util::result::Result isEqual(const dd::BaseUnit& base_unit1,
                                          const dd::BaseUnit& base_unit2,
                                          uint32_t flags = icf_none);

    static a_util::result::Result isEqualType(const std::string& type1,
                                              const std::string& desc1,
                                              const std::string& type2,
                                              const std::string& desc2,
                                              uint32_t flags = icf_memory);

    static a_util::result::Result isEqual(const dd::DataType& type1,
                                          const dd::DataType& type2,
                                          uint32_t flags = icf_memory);

    static a_util::result::Result isEqual(const dd::EnumType& enum1,
                                          const dd::DataDefinition& source_dd_of_enum1,
                                          const dd::EnumType& enum2,
                                          const dd::DataDefinition& source_dd_of_enum2,
                                          uint32_t flags = icf_memory);

    static a_util::result::Result isEqual(const dd::StructType& type1,
                                          const dd::DataDefinition& source_dd_of_type1,
                                          const dd::StructType& type2,
                                          const dd::DataDefinition& source_dd_of_type2,
                                          uint32_t flags = icf_memory);

    static a_util::result::Result isEqualStream(const std::string& stream1,
                                                const std::string& desc1,
                                                const std::string& stream2,
                                                const std::string& desc2,
                                                uint32_t flags = icf_memory);

    static a_util::result::Result isEqual(const dd::Stream& stream1,
                                          const dd::DataDefinition& source_dd_of_stream1,
                                          const dd::Stream& stream2,
                                          const dd::DataDefinition& source_dd_of_stream2,
                                          uint32_t flags = icf_memory);

    static a_util::result::Result isEqual(const dd::StreamMetaType& stream_meta_type1,
                                          const dd::DataDefinition& source_dd_of_stream_meta_type1,
                                          const dd::StreamMetaType& stream_meta_type2,
                                          const dd::DataDefinition& source_dd_of_stream_meta_type2,
                                          uint32_t flags = icf_memory);
 
    // sub-item comparison

    static a_util::result::Result isEqual(const dd::datamodel::KeyValuePair& key_value_pair1,
                                          const dd::datamodel::KeyValuePair& key_value_pair2,
                                          uint32_t flags = icf_none);

    static a_util::result::Result isEqual(const dd::Unit::RefUnit& ref_unit1,
                                          const dd::DataDefinition& source_dd_of_ref_unit1,
                                          const dd::Unit::RefUnit& ref_unit2,
                                          const dd::DataDefinition& source_dd_of_ref_unit2,
                                          uint32_t flags = icf_none);

    static a_util::result::Result isEqual(const dd::StructType::Element& elem1,
                                          const dd::DataDefinition& source_dd_of_elem1,
                                          const dd::StructType::Element& elem2,
                                          const dd::DataDefinition& source_dd_of_elem2,
                                          uint32_t flags = icf_none);

    static a_util::result::Result isEqual(const dd::Stream::Struct& stream_struct1,
                                          const dd::DataDefinition& source_dd_of_stream_struct1,
                                          const dd::Stream::Struct& stream_struct2,
                                          const dd::DataDefinition& source_dd_of_stream_struct2,
                                          uint32_t flags = icf_none);
 
    // description based methods

    static a_util::result::Result isEqual(const std::string& desc1,
                                          const std::string& desc2,
                                          uint32_t flags = dcf_all | dcf_subset);

    static a_util::result::Result isEqual(const dd::DataDefinition& desc1,
                                          const dd::DataDefinition& desc2,
                                          uint32_t flags = dcf_all | dcf_subset);
};
 
} // namespace ddl
 
#endif // DDCOMPARE_H_INCLUDED