FGPropertyManager.h

Go to the documentation of this file.

/*
 * SPDX-FileName: FGPropertyManager.h
 * SPDX-FileComment: Based on work originally by David Megginson
 * SPDX-FileCopyrightText: Copyright (C) 2002  Tony Peden
 * SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SENTRY
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#pragma once
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
// This is needed by MSVC9 when included in FlightGear because of
// the new Vec4d class in props.hxx
#if defined(HAVE_CONFIG_H)
#include <config.h>
#endif
 
#include <string>
 
#include "simgear/props/propertyObject.hxx"
#if !PROPS_STANDALONE
#include "simgear/math/SGMath.hxx"
#endif
 
#include "FGJSBBase.h"
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FORWARD DECLARATIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
namespace JSBSim {
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class FGPropertyNode : public SGPropertyNode
{
public:
    virtual ~FGPropertyNode(void) {}

    FGPropertyNode*
    GetNode(const std::string& path, bool create = false);
 
    FGPropertyNode*
    GetNode(const std::string& relpath, int index, bool create = false);

    bool HasNode(const std::string& path);

    const std::string& GetName(void) const { return getNameString(); }

    std::string GetPrintableName(void) const;

    std::string GetFullyQualifiedName(void) const;

    std::string GetRelativeName(const std::string& path = "/fdm/jsbsim/") const;

    bool GetBool(const std::string& name, bool defaultValue = false) const;
 

    int GetInt(const std::string& name, int defaultValue = 0) const;
 

    int GetLong(const std::string& name, long defaultValue = 0L) const;
 

    float GetFloat(const std::string& name, float defaultValue = 0.0) const;
 

    double GetDouble(const std::string& name, double defaultValue = 0.0) const;
 

    std::string GetString(const std::string& name, std::string defaultValue = "") const;
 

    bool SetBool(const std::string& name, bool val);
 

    bool SetInt(const std::string& name, int val);
 

    bool SetLong(const std::string& name, long val);
 

    bool SetFloat(const std::string& name, float val);
 

    bool SetDouble(const std::string& name, double val);
 

    bool SetString(const std::string& name, const std::string& val);
 

    // Convenience functions for setting property attributes.
 

    void SetArchivable(const std::string& name, bool state = true);
 

    void SetReadable(const std::string& name, bool state = true);
 

    void SetWritable(const std::string& name, bool state = true);
};
 
typedef SGSharedPtr<FGPropertyNode> FGPropertyNode_ptr;
typedef SGSharedPtr<const FGPropertyNode> FGConstPropertyNode_ptr;
 
class FGPropertyManager
{
public:
    FGPropertyManager(void) { root = new FGPropertyNode; }

    explicit FGPropertyManager(FGPropertyNode* _root) : root(_root){};

    virtual ~FGPropertyManager(void) { Unbind(); }
 
    FGPropertyNode* GetNode(void) const { return root; }
    FGPropertyNode* GetNode(const std::string& path, bool create = false)
    {
        return root->GetNode(path, create);
    }
    FGPropertyNode* GetNode(const std::string& relpath, int index, bool create = false)
    {
        return root->GetNode(relpath, index, create);
    }
    bool HasNode(const std::string& path) const
    {
        std::string newPath = path;
        if (newPath[0] == '-') newPath.erase(0, 1);
        return root->HasNode(newPath);
    }

    std::string mkPropertyName(std::string name, bool lowercase);

    // Convenience functions for tying properties, with logging.
 

    void Untie(const std::string& name);

    void Untie(SGPropertyNode* property);

    void Unbind(void);

    template <typename T>
    void
    Tie(const std::string& name, T* pointer)
    {
        SGPropertyNode* property = root->getNode(name.c_str(), true);
        if (!property) {
            std::cerr << "Could not get or create property " << name << std::endl;
            return;
        }
 
        if (!property->tie(SGRawValuePointer<T>(pointer), false))
            std::cerr << "Failed to tie property " << name << " to a pointer" << std::endl;
        else {
            tied_properties.push_back(property);
            if (FGJSBBase::debug_lvl & 0x20) std::cout << name << std::endl;
        }
    }

 
    template <typename T>
    void
    Tie(const std::string& name, T (*getter)(), void (*setter)(T) = nullptr)
    {
        SGPropertyNode* property = root->getNode(name.c_str(), true);
        if (!property) {
            std::cerr << "Could not get or create property " << name << std::endl;
            return;
        }
 
        if (!property->tie(SGRawValueFunctions<T>(getter, setter), false))
            std::cerr << "Failed to tie property " << name << " to functions"
                      << std::endl;
        else {
            if (!setter) property->setAttribute(SGPropertyNode::WRITE, false);
            if (!getter) property->setAttribute(SGPropertyNode::READ, false);
            tied_properties.push_back(property);
            if (FGJSBBase::debug_lvl & 0x20) std::cout << name << std::endl;
        }
    }

    template <typename T>
    void
    Tie(const std::string& name, int index, T (*getter)(int),
        void (*setter)(int, T) = nullptr)
    {
        SGPropertyNode* property = root->getNode(name.c_str(), true);
        if (!property) {
            std::cerr << "Could not get or create property " << name << std::endl;
            return;
        }
 
        if (!property->tie(SGRawValueFunctionsIndexed<T>(index, getter, setter),
                           false))
            std::cerr << "Failed to tie property " << name << " to indexed functions"
                      << std::endl;
        else {
            if (!setter) property->setAttribute(SGPropertyNode::WRITE, false);
            if (!getter) property->setAttribute(SGPropertyNode::READ, false);
            tied_properties.push_back(property);
            if (FGJSBBase::debug_lvl & 0x20) std::cout << name << std::endl;
        }
    }

    template <class T, class V>
    void
    Tie(const std::string& name, T* obj, V (T::*getter)() const,
        void (T::*setter)(V) = nullptr)
    {
        SGPropertyNode* property = root->getNode(name.c_str(), true);
        if (!property) {
            std::cerr << "Could not get or create property " << name << std::endl;
            return;
        }
 
        if (!property->tie(SGRawValueMethods<T, V>(*obj, getter, setter), false))
            std::cerr << "Failed to tie property " << name << " to object methods"
                      << std::endl;
        else {
            if (!setter) property->setAttribute(SGPropertyNode::WRITE, false);
            if (!getter) property->setAttribute(SGPropertyNode::READ, false);
            tied_properties.push_back(property);
            if (FGJSBBase::debug_lvl & 0x20) std::cout << name << std::endl;
        }
    }

    template <class T, class V>
    void
    Tie(const std::string& name, T* obj, int index, V (T::*getter)(int) const,
        void (T::*setter)(int, V) = nullptr)
    {
        SGPropertyNode* property = root->getNode(name.c_str(), true);
        if (!property) {
            std::cerr << "Could not get or create property " << name << std::endl;
            return;
        }
 
        if (!property->tie(SGRawValueMethodsIndexed<T, V>(*obj, index, getter, setter),
                           false))
            std::cerr << "Failed to tie property " << name
                      << " to indexed object methods" << std::endl;
        else {
            if (!setter) property->setAttribute(SGPropertyNode::WRITE, false);
            if (!getter) property->setAttribute(SGPropertyNode::READ, false);
            tied_properties.push_back(property);
            if (FGJSBBase::debug_lvl & 0x20) std::cout << name << std::endl;
        }
    }
 
    template <class T>
    simgear::PropertyObject<T>
    CreatePropertyObject(const std::string& path)
    {
        return simgear::PropertyObject<T>(root->GetNode(path, true));
    }
 
private:
    std::vector<SGPropertyNode_ptr> tied_properties;
    FGPropertyNode_ptr root;
};
} // namespace JSBSim