InstanceIdPolicy.h

Go to the documentation of this file.

#ifndef SAFIR_DOB_INSTANCEIDPOLICY_H_INCLUDED
#define SAFIR_DOB_INSTANCEIDPOLICY_H_INCLUDED

#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/Utilities/Internal/VisibilityHelpers.h>

#ifdef dots_generated_Safir_cpp_EXPORTS
#  define DOTS_GENERATED_Safir_API SAFIR_HELPER_DLL_EXPORT
#else
#  define DOTS_GENERATED_Safir_API SAFIR_HELPER_DLL_IMPORT
#  define SAFIR_LIBRARY_NAME "dots_generated-Safir-cpp"
#  include <Safir/Utilities/Internal/AutoLink.h>
#endif
#define DOTS_GENERATED_Safir_API_LOCAL SAFIR_HELPER_DLL_LOCAL

namespace Safir
{
namespace Dob
{

    struct DOTS_GENERATED_Safir_API InstanceIdPolicy
    {
        enum Enumeration
        {
            HandlerDecidesInstanceId = 0,
            RequestorDecidesInstanceId
        };


        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 = 2097100482419623062LL;
        static const Safir::Dob::Typesystem::TypeId Checksum = 1031390732314968761LL;

        //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
            virtual void SetOrdinal(const Safir::Dob::Typesystem::EnumerationValue value)
            {
                if (value < FirstOrdinal() || value > LastOrdinal())
                {
                    throw Safir::Dob::Typesystem::IllegalValueException(L"The enumerated type Safir.Dob.InstanceIdPolicy does not have such a value",__WFILE__,__LINE__);
                }
                m_bIsNull = false;
                m_bIsChanged = true;
                m_Value = value;
            }

            virtual Safir::Dob::Typesystem::EnumerationValue GetOrdinal() const
            {
                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());
            }

            //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;

    };
    static inline bool operator==(const InstanceIdPolicy::Enumeration first, const InstanceIdPolicy::EnumerationContainer second)
    {return second == first;}

    static inline bool operator!=(const InstanceIdPolicy::Enumeration first, const InstanceIdPolicy::EnumerationContainer second)
    {return !(first == second);}

} // Dob
} // Safir

#endif