WsfVariable.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFVARIABLE_HPP
#define WSFVARIABLE_HPP
 
#include "wsf_export.h"
 
#include <iosfwd>
#include <string>
 
#include "UtInput.hpp"
class UtScriptContext;
#include "UtScriptData.hpp"
class WsfComponent;
class WsfScriptContext;
class WsfScriptManager;
#include "WsfStringId.hpp"

 
//-------------------------------------------------------------------------------------------------
class WSF_EXPORT WsfVariableBase
{
public:
   // NOTE: The default (member-wise) copy constructor and assignment operator are used.
 
   WsfVariableBase();

   bool HasDefaultValue() const { return mHasDefaultValue; }

   bool IsReference() const { return !mRefVarNameId.IsNull(); }
 
protected:
   bool DefaultOptionPresent(UtInput& aInput);
 
   std::string ObjectName(WsfComponent* aObjectPtr);
 
   bool ReadReference(UtInput& aInput);
 
   bool ResolveReference(const std::string&   aVariableName,
                         WsfComponent*        aObjectPtr,
                         WsfScriptContext*    aContextPtr,
                         const UtScriptData*& aRefValuePtr,
                         WsfScriptContext&    aGlobalContext);


   bool Initialize(const std::string& aName,
                   WsfComponent*      aObjectPtr,
                   WsfScriptContext*  aContextPtr,
                   double&            aValue,
                   WsfScriptContext&  aGlobalContext);
 
   void ReadValue(UtInput& aInput, double& aValue);
 
   void ReadValueOfType(UtInput& aInput, UtInput::ValueType aType, double& aValue);


   bool Initialize(const std::string& aName,
                   WsfComponent*      aObjectPtr,
                   WsfScriptContext*  aContextPtr,
                   float&             aValue,
                   WsfScriptContext&  aGlobalContext);
 
   void ReadValue(UtInput& aInput, float& aValue);
 
   void ReadValueOfType(UtInput& aInput, UtInput::ValueType aType, float& aValue);


   bool Initialize(const std::string& aName,
                   WsfComponent*      aObjectPtr,
                   WsfScriptContext*  aContextPtr,
                   int&               aValue,
                   WsfScriptContext&  aGlobalContext);
 
   void ReadValue(UtInput& aInput, int& aValue);
 
   void ReadValueOfType(UtInput& aInput, UtInput::ValueType aType, int& aValue);


   bool Initialize(const std::string& aName,
                   WsfComponent*      aObjectPtr,
                   WsfScriptContext*  aContextPtr,
                   bool&              aValue,
                   WsfScriptContext&  aGlobalContext);
 
   void ReadValue(UtInput& aInput, bool& aValue);


   bool Initialize(const std::string& aName,
                   WsfComponent*      aObjectPtr,
                   WsfScriptContext*  aContextPtr,
                   std::string&       aValue,
                   WsfScriptContext&  aGlobalContext);
 
   void ReadValue(UtInput& aInput, std::string& aValue);


   bool Initialize(const std::string& aName,
                   WsfComponent*      aObjectPtr,
                   WsfScriptContext*  aContextPtr,
                   WsfStringId&       aValue,
                   WsfScriptContext&  aGlobalContext);
 
   void ReadValue(UtInput& aInput, WsfStringId& aValue);

   WsfStringId mRefVarNameId;

   bool mHasDefaultValue;
};
 
//-------------------------------------------------------------------------------------------------
template<typename T>
class WsfVariable : public WsfVariableBase
{
public:
   // NOTE: The default (member-wise) copy constructor and assignment operator are used.
   //       Copying or assigning a 'Initialize'd variable is OK as long as the copy would also
   //       refer to the same script context.
 
   WsfVariable() = default;
 
   WsfVariable(const T& aInitialValue)
      : WsfVariableBase()
      , mValue(aInitialValue)
   {
   }
 
   WsfVariable(const WsfVariable<T>&) = default;

   operator T() const { return mValue; }
 
   T GetValue() const { return mValue; }
 
   WsfVariable<T>& operator=(const T& aRhs)
   {
      mRefVarNameId.Clear();
      mHasDefaultValue = false;
      mValue           = aRhs;
      return *this;
   }
 
   WsfVariable<T>& operator=(const WsfVariable<T>& aRhs)
   {
      mRefVarNameId    = aRhs.mRefVarNameId;
      mHasDefaultValue = aRhs.mHasDefaultValue;
      mValue           = aRhs.mValue;
      return *this;
   }
 
   T operator+(const T& aRhs) const { return operator T() + aRhs; }
 
   T operator-(const T& aRhs) const { return operator T() - aRhs; }
 
   T& operator+=(const T& aRhs)
   {
      mRefVarNameId.Clear();
      mHasDefaultValue = false;
      mValue           = operator T() + aRhs;
      return mValue;
   }
 
   T& operator-=(const T& aRhs)
   {
      mRefVarNameId.Clear();
      mHasDefaultValue = false;
      mValue           = operator T() - aRhs;
      return mValue;
   }

   bool Initialize(const std::string& aName,
                   WsfComponent*      aObjectPtr,
                   WsfScriptContext*  aContextPtr,
                   WsfScriptContext&  aGlobalContext)
   {
      return WsfVariableBase::Initialize(aName, aObjectPtr, aContextPtr, mValue, aGlobalContext);
   }

   void ReadValue(UtInput& aInput) { return WsfVariableBase::ReadValue(aInput, mValue); }

   void ReadValueOfType(UtInput& aInput, UtInput::ValueType aType)
   {
      return WsfVariableBase::ReadValueOfType(aInput, aType, mValue);
   }

   void ValueInClosedRange(UtInput& aInput, T aMinValue, T aMaxValue)
   {
      if ((!IsReference()) || HasDefaultValue())
      {
         aInput.ValueInClosedRange(mValue, aMinValue, aMaxValue);
      }
   }

   void ValueGreater(UtInput& aInput, T aMinValue)
   {
      if ((!IsReference()) || HasDefaultValue())
      {
         aInput.ValueGreater(mValue, aMinValue);
      }
   }

   void ValueGreaterOrEqual(UtInput& aInput, T aMinValue)
   {
      if ((!IsReference()) || HasDefaultValue())
      {
         aInput.ValueGreaterOrEqual(mValue, aMinValue);
      }
   }

   void ValueLess(UtInput& aInput, T aMaxValue)
   {
      if ((!IsReference()) || HasDefaultValue())
      {
         aInput.ValueLess(mValue, aMaxValue);
      }
   }

   void ValueLessOrEqual(UtInput& aInput, T aMaxValue)
   {
      if ((!IsReference()) || HasDefaultValue())
      {
         aInput.ValueLessOrEqual(mValue, aMaxValue);
      }
   }
 
private:
   T mValue;
};
 
// ================================================================================================
// Explicit specialization of WsfVariable for WsfStringId.
 
template<>
class WsfVariable<WsfStringId> : public WsfVariableBase
{
public:
   WsfVariable() = default;
 
   WsfVariable(const std::string& aInitialValue)
      : WsfVariableBase()
      , mValue(aInitialValue)
   {
   }
 
   WsfVariable(WsfStringId aInitialValue)
      : WsfVariableBase()
      , mValue(aInitialValue)
   {
   }
 
   WsfStringId operator=(const std::string& aValue)
   {
      mValue = aValue;
      return mValue;
   }
 
   WsfStringId operator=(WsfStringId aValue)
   {
      mValue = aValue;
      return mValue;
   }
 
   operator WsfStringId() const { return mValue; }
 
   operator const std::string&() const { return mValue.GetString(); }
 
   WsfStringId GetId() const { return mValue; }
 
   const std::string& GetString() const { return mValue.GetString(); }
 
   WsfStringId GetConstReference() const { return mValue; }

   bool Initialize(const std::string& aName,
                   WsfComponent*      aObjectPtr,
                   WsfScriptContext*  aContextPtr,
                   WsfScriptContext&  aGlobalContext)
   {
      return WsfVariableBase::Initialize(aName, aObjectPtr, aContextPtr, mValue, aGlobalContext);
   }

   void ReadValue(UtInput& aInput) { WsfVariableBase::ReadValue(aInput, mValue); }
 
private:
   WsfStringId mValue;
};
 
// ================================================================================================
// A stream inserter is defined for a WsfVariable<std::string> or WsfVariable<WsfStringId> because
// the normal casting operator did not work (it worked for POD's, but not class types).
 
std::ostream& operator<<(std::ostream& aOut, const WsfVariable<std::string>& aVariable);
 
std::ostream& operator<<(std::ostream& aOut, const WsfVariable<WsfStringId>& aVariable);
 
#endif