InjectionKind.h

Go to the documentation of this file.

#pragma once
 
#include <Safir/Dob/Typesystem/Defs.h>
#include <Safir/Dob/Typesystem/Operations.h>
#include <Safir/Dob/Typesystem/EnumerationContainerBase.h>
#include <Safir/Dob/Typesystem/ArrayContainer.h>
#include <Safir/Dob/Typesystem/SequenceContainer.h>
#include <Safir/Utilities/Internal/VisibilityHelpers.h>
 
#ifdef safir_generated_Core_cpp_EXPORTS
#  define SAFIR_GENERATED_Core_API SAFIR_HELPER_DLL_EXPORT
#else
#  define SAFIR_GENERATED_Core_API SAFIR_HELPER_DLL_IMPORT
#  define SAFIR_LIBRARY_NAME "safir_generated-Core-cpp"
#  include <Safir/Utilities/Internal/AutoLink.h>
#endif
#define SAFIR_GENERATED_Core_API_LOCAL SAFIR_HELPER_DLL_LOCAL

namespace Safir
{
namespace Dob
{

 
    struct SAFIR_GENERATED_Core_API InjectionKind
    {
        enum Enumeration
        {
            None = 0,
            SynchronousVolatile,
            SynchronousPermanent,
            Injectable
        };
 
 
        static Safir::Dob::Typesystem::Int32 Size();
        static Enumeration First();
        static Enumeration Last();
 
        static Safir::Dob::Typesystem::EnumerationValue FirstOrdinal();
        static Safir::Dob::Typesystem::EnumerationValue LastOrdinal();
 
        static std::wstring ToString(const Enumeration enumVal);
        static Enumeration ToValue(const std::wstring & valueString);
 
        static const Safir::Dob::Typesystem::TypeId EnumerationTypeId = 6404762710716671877LL;
        static const Safir::Dob::Typesystem::TypeId Checksum = -9187819218818002410LL;
 
        //Check that there is no enumeration mismatch
        //throws an exception if there is - ConfigurationErrorException
        static void CheckForMismatch(const Safir::Dob::Typesystem::TypeId checksum = Checksum);
 
        class EnumerationContainer : public Safir::Dob::Typesystem::EnumerationContainerBase
        {
        public:
            typedef Enumeration ContainedType;
 
            //Will throw IllegalValueException if value is not in first .. last
            void SetOrdinal(const Safir::Dob::Typesystem::EnumerationValue value) override
            {
                if (value < FirstOrdinal() || value > LastOrdinal())
                {
                    throw Safir::Dob::Typesystem::IllegalValueException(L"The enumerated type Safir.Dob.InjectionKind does not have such a value",__WFILE__,__LINE__);
                }
                m_bIsNull = false;
                m_bIsChanged = true;
                m_Value = value;
            }
 
            Safir::Dob::Typesystem::EnumerationValue GetOrdinal() const override
            {
                if (IsNull())
                {
                    throw Safir::Dob::Typesystem::NullException(L"Value is null",__WFILE__,__LINE__);
                }
                return m_Value;
            }
 
            //Will throw ConfigurationErrorException if there is an enumeration mismatch
            void SetVal(const Enumeration value)
            {
                CheckForMismatch();
                SetOrdinal(value);
            }
 
            //Will throw ConfigurationErrorException if there is an enumeration mismatch
            Enumeration GetVal() const
            {
                CheckForMismatch();
                return static_cast<Enumeration>(GetOrdinal());
            }
 
            //Will get the value if container is not null, else the supplied default value is returned.
            Enumeration GetValOrDefault(const Enumeration defaultVal) const
            {
                CheckForMismatch();
                return IsNull() ? defaultVal : static_cast<Enumeration>(GetOrdinal());
            }
 
            //compare an enumerationcontainer with a value, will return false if the container is null or the values are not equal
            bool operator==(const Enumeration other) const
            {CheckForMismatch(); return !IsNull() && m_Value == other;}
 
            bool operator != (const Enumeration other) const
            {return !(*this == other);}
        };
 
        typedef Safir::Dob::Typesystem::ArrayContainer<EnumerationContainer> EnumerationContainerArray;
        typedef Safir::Dob::Typesystem::EnumerationSequenceContainer<InjectionKind> EnumerationSequenceContainer;
 
    };
    static inline bool operator==(const InjectionKind::Enumeration first, const InjectionKind::EnumerationContainer& second)
    {return second == first;}
 
    static inline bool operator!=(const InjectionKind::Enumeration first, const InjectionKind::EnumerationContainer& second)
    {return !(first == second);}
 
} // Dob
} // Safir