parsys.hh

Go to the documentation of this file.

#ifndef _DRAMA2_PARSYS_INC
#define _DRAMA2_PARSYS_INC
/*
 *  History:
      14-Jul-2014 - TJF - Original version, based on Sdp.h
      14-Jun-2018 - TJF - Get() method and similar should be const.
 
 * The above ID is for Doxygen, this one has the format ACMM is looking for.
 * "@(#) $Id$"
 */
 
#include "drama/task.hh"
#include "drama/sds.hh"
#include <string>
#include "Sdp.h"
#include "DitsParam.h"
 
 
 
namespace drama {
 
    class ParSys {
        friend class ParId;
    private:
        /*
         * Pointer to the DRAMA task this parameter system is part of.
         */
        std::weak_ptr<Task> _theTask;
 
    public:
        ParSys(std::weak_ptr<Task> dramaTask) : _theTask(dramaTask) {}
 
        void CreateItem(sds::Id &item) {
 
            // Lock access to DRAMA.
            Task::guardType DramaLock(std::shared_ptr<Task>(_theTask)->Lock());
 
            StatusType status = STATUS__OK;
 
            SdpCreateItem((SdsIdType)(DitsGetParId()),(SdsIdType)item,&status);
            if (status != STATUS__OK)
                DramaTHROW(status,
                           "Failed to create new structured parameter");
 
            /* Ensure item is not deleted by destructor (id can go) */
            item.ClearDelete();
        }
 
        template <typename T>
        void Create (const std::string &name, T value) {
 
            // Lock access to DRAMA.
            Task::guardType DramaLock(std::shared_ptr<Task>(_theTask)->Lock());
 
            // Access the parameter system SDS ID.
            sds::Id parSysId = sds::Id::CreateFromSdsId((SdsIdType)(DitsGetParId()));
 
            // Use the SDS ID to create the item.
            parSysId.Put(name, value);
    
        }
        void Create (const std::string &name, const std::string &value) {
 
            // Lock access to DRAMA.
            Task::guardType DramaLock(std::shared_ptr<Task>(_theTask)->Lock());
 
            // Access the parameter system SDS ID.
            sds::Id parSysId = sds::Id::CreateFromSdsId((SdsIdType)(DitsGetParId()));
 
            // Use the SDS ID to create the item.
            parSysId.Put(name, value);
    
 
 
        }       
       sds::Id CreateSds(const std::string &name, SdsCodeType code, const std::string &extra = "")  {
 
            // Lock access to DRAMA.
            Task::guardType DramaLock(std::shared_ptr<Task>(_theTask)->Lock());
 
            // Access the parameter system SDS ID.
            sds::Id parSysId = sds::Id::CreateFromSdsId((SdsIdType)(DitsGetParId()));
 
 
           // Use sds to create the item
           return parSysId.CreateChildItem(name, code, extra);
       }
 
 
        bool Exists(const std::string &name) const {
            
            // Lock access to DRAMA.
            Task::guardType DramaLock(std::shared_ptr<Task>(_theTask)->Lock());
 
            // Access the parameter system SDS ID.
            sds::Id parSysId = sds::Id::CreateFromSdsId((SdsIdType)(DitsGetParId()));
            return parSysId.Exists(name);
        }
 
    private:
        /*
         * The SdpPut() template function is used by the Put() method
         * of ParSys which is implementing traditional Sdp style Put.
         *
         * The idea is that we must instantiate a specific version of this
         * for each primitive SDS type and for strings.  This is done  
         * outside the class definition.
         *
         * The Put() method won't link unless there is a specific version for
         *  the type in question.
         *
         * DRAMA Lock will be taken when invoked.
         */
        template <typename T> static void SdpPut(
            const std::string &name, 
            T value, StatusType *status); 
 
 
        /*
         * The SdpGet() template function is used by the Get() method
         * of ParSys and is implementing traditional Sdp style Get.
         *
         * The idea is that we must instantiate a specific version of this
         * for each primitive SDS type and for strings.  These are done  
         * outside the class definition at the bottom of this file.
         *
         * The Get() method won't link unless there is a specific version for
         *  the type in question.
         *
         * DRAMA Lock will be taken when invoked.
         */
        template <typename T> static void SdpGet(
            const std::string &name, 
            T *value, StatusType *status); 
 
 
    public:
 
        template <typename T>
        void Get (const std::string &name, T *value) const {
 
            // Lock access to DRAMA.
            Task::guardType DramaLock(std::shared_ptr<Task>(_theTask)->Lock());
                
            StatusType status = STATUS__OK;
            /* 
               There must be a specialization of SdpGet() which
               supports type T.  Note that conversion  of DRAMA status
               to DRAMA 2 exceptions is done here so it need only be
               done once.
             */
            SdpGet(name, value, &status);
            if (status != STATUS__OK)
                DramaTHROW_S(status, 
                             "SdpGet of parameter % failed",
                             name);
    
        }
        template <typename T>
        void Put (const std::string &name, T value) {
 
            /*
             * Confirm the data type is a POD type.
             *   From C++20, std::is_pod<>() is depreciated, we can replace 
             *     by std::is_standard_layout<>::value && std::is_trivial<>::value
             */
            static_assert(
                (std::is_standard_layout<T>::value && std::is_trivial<T>::value   ) ,
                "The type T must be a standard layout and trivial (POD) type");
 
            static_assert(
                (std::is_integral<T>::value or std::is_floating_point<T>::value),
                "The type T must be integral or floating point");
 
            // Lock access to DRAMA.
            Task::guardType DramaLock(std::shared_ptr<Task>(_theTask)->Lock());
                
            StatusType status = STATUS__OK;
            /* 
               There must be a specialization of SdpPut() which
               supports type T.  Note that conversion  of DRAMA status
               to DRAMA 2 exceptions is done here so it need only be
               done once.
             */
            SdpPut(name, value, &status);
            if (status != STATUS__OK)
                DramaTHROW_S(status, 
                             "SdpPut of parameter % failed",
                             name);
    
        }
        void  Put(const std::string &name, const char *value);
 
 
        void Put (const std::string &name, const std::string &value);
 
        int GetInt(const std::string &name) const;
        unsigned int GetUInt(const std::string &name) const;
 
        long GetLong(const std::string &name) const;
        unsigned long GetULong(const std::string &name) const;
        double GetDouble(const std::string &name) const;
        
        std::string GetString(const std::string &name) const;
 
 
        void PutSdsCvt(const std::string &name, 
                              const sds::Id & value);
 
        void PutSdsReplaceByCopy(const std::string &name, 
                                        const sds::Id &value,
                                        const bool create=true );
        
        void PutSdsReplaceByInsert(const std::string &name, 
                                        sds::Id *value,
                                        const bool create=true );
 
        void Update(const std::string &name);
 
 
    }; // class ParSys.
 
    /*
     * The SdpPut() template function is used by  the Put() method 
     * of ParSys. 
     *
     * The idea is that we must instantiate a specific version of this
     * for each primitive SDS item (and for strings).  
     *
     * The Put method won't link unless there is a specific version for
     *  the type in question.  These are all implemented in parsys.cpp.
     */
    template <> void ParSys::SdpPut<bool>(
        const std::string &name, 
        bool value, StatusType *status);
    template <> void ParSys::SdpPut<char>(
        const std::string &name, 
        char value, StatusType *status);
    template <> void ParSys::SdpPut<short>(
        const std::string &name, 
        short value, StatusType *status);
    template <> void ParSys::SdpPut<unsigned short>(
        const std::string &name, 
        unsigned short value, StatusType *status);
    template <> void ParSys::SdpPut<INT32>(
        const std::string &name, 
        INT32 value, StatusType *status);
    template <> void ParSys::SdpPut<UINT32>(
        const std::string &name, 
        UINT32 value, StatusType *status);
    template <> void ParSys::SdpPut<INT64>(
        const std::string &name, 
        INT64 value, StatusType *status);
    template <> void ParSys::SdpPut<UINT64>(
        const std::string &name, 
        UINT64 value, StatusType *status);
    template <> void ParSys::SdpPut<float>(
        const std::string &name, 
        float value, StatusType *status);
    template <> void ParSys::SdpPut<double>(
        const std::string &name, 
        double value, StatusType *status);
 
 
    template <> void ParSys::SdpPut<const char *>(
        const std::string &name, 
        const char *value, StatusType *status);
 
    template <> void ParSys::SdpPut<const std::string&>(
        const std::string &name, 
        const std::string &value, StatusType *status);
 
    /*
     * The SdpGet() template function is used by  the Get() method 
     * of ParSys. 
     *
     * The idea is that we must instantiate a specific version of this
     * for each primitive SDS item (and for strings).  
     *
     * The Get method won't link unless there is a specific version for
     *  the type in question.  These are all implemented in parsys.cpp.
     *
     * Note - we have a Get() of an SDS type, but not a Put, there are
     * specific PutSds... methods in ParSys for different cases.
     */
 
 
    template <> void ParSys::SdpGet<bool>(
        const std::string &name, 
        bool *value, StatusType *status);
    template <> void ParSys::SdpGet<char>(
        const std::string &name, 
        char *value, StatusType *status);
    template <> void ParSys::SdpGet<short>(
        const std::string &name, 
        short *value, StatusType *status);
    template <> void ParSys::SdpGet<unsigned short>(
        const std::string &name, 
        unsigned short *value, StatusType *status);
    template <> void ParSys::SdpGet<INT32>(
        const std::string &name, 
        INT32 *value, StatusType *status);
    template <> void ParSys::SdpGet<UINT32>(
        const std::string &name, 
        UINT32 *value, StatusType *status);
    template <> void ParSys::SdpGet<INT64>(
        const std::string &name, 
        INT64 *value, StatusType *status);
    template <> void ParSys::SdpGet<UINT64>(
        const std::string &name, 
        UINT64 *value, StatusType *status);
    template <> void ParSys::SdpGet<float>(
        const std::string &name, 
        float *value, StatusType *status);
    template <> void ParSys::SdpGet<double>(
        const std::string &name, 
        double *value, StatusType *status);
    template <> void ParSys::SdpGet<std::string>(
        const std::string &name, 
        std::string *value, StatusType *status);
#if 0
    template <> void ParSys::SdpGet<sds::Id>(
        const std::string &name, 
        sds::Id *parId, StatusType *status);
#endif
 
 
    class ParId : public sds::Id {
    private:
        /*
         * Pointer to the DRAMA task this parameter system is part of.
         */
        std::weak_ptr<Task> _theTask;
 
        void InvalidCall(const std::string &fromWhere);
 
        /*
         * Various SDS methods are not allowed, make them private and
         * (incase they are invoked in the class itself) replace them
         * such that they throw an exception.
         *
         * We can't just delete these - Under the C++11 standard,  a deleted 
         * virtual function may not override a non-deleted virtual function 
         *
         * We don't need to change the free flag - it is set correctly.
         */
        void SetFree() override final {
            InvalidCall("SetFree()");
        }
        
        // Don't allow delete to be set - that would remove the parameter.
        void SetDelete() override final {
            InvalidCall("SetDelete()");
        }
 
        // Not needed, delete will never be set.
        void ClearDelete() override final {
            InvalidCall("ClearDelete()");
        }
 
        // Not needed - outlives anyway.
        void Outlive() override final {
            InvalidCall("Outlive()");
        }
        // Can't delete- that will kill the parameter, mess up monitors.
        void Delete() override final {
            InvalidCall("Delete()");
        }
        //Would remove the parameter from the parameter system,mess up monitors 
        void Extract() override final {
            InvalidCall("Extract()");
        }
        // Potential to mess up parameter monitors.
        void Rename(const std::string &) override final {
            InvalidCall("Rename()");
        }
        // Lots of potential to mess things up.
        SdsIdType COut(const bool /*outlives*/, 
                       bool * const /*free*/ = 0,
                       bool * const /*del*/= 0, 
                       bool * const /*readfree*/ = 0) override final {
 
            InvalidCall("COut()");
            return 0;
        }
        // This replaces the current item - messing up the parameter.
        void ShallowCopy (Id * /*source*/, 
                          const bool /*outlives*/=true) override final {
            InvalidCall("ShallowCopy()");
        }
        // This replaces the current item - messing up the parameter.
        void ShallowCopy (const Id & /*source*/) override final {
            InvalidCall("ShallowCopy()");
        }
        void ShallowCopy (const SdsIdType /*source*/, 
                                  const bool /*free*/=false, 
                                  const bool /*del*/ = false, 
                                  const bool /*readfree*/ = false) override final {
            InvalidCall("ShallowCopy()");
        }
 
    public:
        ParId(std::weak_ptr<Task> dramaTask, const std::string& name);
 
        ParId(ParSys *parSys, const std::string& name);
 
 
        void Update() const;
        virtual ~ParId();
    }; // class ParId
 
} // namespace drama
 
#endif  /* defined _DRAMA2_SDP_INC */