PersistentDataState.h

Go to the documentation of this file.

#ifndef SAFIR_DOB_PERSISTENTDATASTATE_H_INCLUDED
#define SAFIR_DOB_PERSISTENTDATASTATE_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>

#ifdef _MSC_VER
#ifdef DOTS_GENERATED_CPP_EXPORTS
#define GENERATED_API __declspec(dllexport)
#else
#define GENERATED_API __declspec(dllimport)
#ifdef _DEBUG
#pragma comment( lib, "dots_generated-Safir-cppd.lib" )
#else
#pragma comment( lib, "dots_generated-Safir-cpp.lib" )
#endif
#endif
#endif
#ifdef __GNUC__
#define GENERATED_API
#endif

namespace Safir
{
namespace Dob
{

    struct GENERATED_API PersistentDataState
    {
        enum Enumeration
        {
            Init = 0,
            Started
        };


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

        //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.PersistentDataState 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 PersistentDataState::Enumeration first, const PersistentDataState::EnumerationContainer second)
    {return second == first;}

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

} // Dob
} // Safir

#endif