FGPropertyManager.h

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 Header:       FGPropertyManager.h
 Author:       Tony Peden
               Based on work originally by David Megginson
 Date:         2/2002
 
 ------------- Copyright (C) 2002 -------------
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the Free Software
 Foundation; either version 2 of the License, or (at your option) any later
 version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 details.
 
 You should have received a copy of the GNU Lesser General Public License along with
 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 Place - Suite 330, Boston, MA  02111-1307, USA.
 
 Further information about the GNU Lesser General Public License can also be found on
 the world wide web at http://www.gnu.org.
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SENTRY
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#ifndef FGPROPERTYMANAGER_H
#define FGPROPERTYMANAGER_H
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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 <list>
#include <memory>
#include "simgear/props/props.hxx"
#if !PROPS_STANDALONE
# include "simgear/math/SGMath.hxx"
#endif
 
#include "FGJSBBase.h"
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FORWARD DECLARATIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
namespace JSBSim {
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class JSBSIM_API 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 JSBSIM_API 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);
 
    void Unbind(const void* instance);
 
    template <typename T> void Unbind(const std::shared_ptr<T>& instance) {
      Unbind(instance.get());
    }
 
    template <typename T> void
    Tie (const std::string &name, T *pointer)
    {
      SGPropertyNode* property = root->getNode(name.c_str(), true);
      if (!property) {
        cerr << "Could not get or create property " << name << endl;
        return;
      }
 
      if (!property->tie(SGRawValuePointer<T>(pointer), false))
        cerr << "Failed to tie property " << name << " to a pointer" << endl;
      else {
        tied_properties.push_back(PropertyState(property, nullptr));
        if (FGJSBBase::debug_lvl & 0x20) cout << name << 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 {
        tied_properties.push_back(PropertyState(property, nullptr));
        if (!setter) property->setAttribute(SGPropertyNode::WRITE, false);
        if (!getter) property->setAttribute(SGPropertyNode::READ, false);
        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 {
        tied_properties.push_back(PropertyState(property, nullptr));
        if (!setter) property->setAttribute(SGPropertyNode::WRITE, false);
        if (!getter) property->setAttribute(SGPropertyNode::READ, false);
        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 {
        tied_properties.push_back(PropertyState(property, obj));
        if (!setter) property->setAttribute(SGPropertyNode::WRITE, false);
        if (!getter) property->setAttribute(SGPropertyNode::READ, false);
        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 {
        tied_properties.push_back(PropertyState(property, obj));
        if (!setter) property->setAttribute(SGPropertyNode::WRITE, false);
        if (!getter) property->setAttribute(SGPropertyNode::READ, false);
        if (FGJSBBase::debug_lvl & 0x20) std::cout << name << std::endl;
      }
   }
 
  private:
    struct PropertyState {
      SGPropertyNode_ptr node;
      const void* BindingInstance = nullptr;
      bool WriteAttribute = true;
      bool ReadAttribute = true;
      PropertyState(SGPropertyNode* property, const void* instance)
        : node(property), BindingInstance(instance) {
        WriteAttribute = node->getAttribute(SGPropertyNode::WRITE);
        ReadAttribute = node->getAttribute(SGPropertyNode::READ);
      }
      void untie(void) {
        node->setAttribute(SGPropertyNode::WRITE, WriteAttribute);
        node->setAttribute(SGPropertyNode::READ, ReadAttribute);
        node->untie();
      }
    };
    std::list<PropertyState> tied_properties;
    FGPropertyNode_ptr root;
};
}
#endif // FGPROPERTYMANAGER_H