opentxs::OTVariable Class Reference

#include <OTVariable.hpp>

Public Types
enum	OTVariable_Type { Var_String, Var_Integer, Var_Bool, Var_Error_Type }
enum	OTVariable_Access { Var_Constant, Var_Persistent, Var_Important, Var_Error_Access }

Public Member Functions
EXPORT void	RegisterForExecution (OTScript &theScript)
EXPORT void	UnregisterScript ()
bool	IsDirty () const
void	SetAsClean ()
bool	IsConstant () const
bool	IsPersistent () const
bool	IsImportant () const
void	SetBylaw (OTBylaw &theBylaw)
bool	SetValue (const int32_t &nValue)
bool	SetValue (bool bValue)
bool	SetValue (const std::string &str_Value)
EXPORT const OTString &	GetName () const
OTVariable_Type	GetType () const
OTVariable_Access	GetAccess () const
bool	IsInteger () const
bool	IsBool () const
bool	IsString () const
int32_t	CopyValueInteger () const
bool	CopyValueBool () const
std::string	CopyValueString () const
int32_t &	GetValueInteger ()
bool &	GetValueBool ()
std::string &	GetValueString ()
bool	Compare (OTVariable &rhs)
EXPORT	OTVariable ()
EXPORT	OTVariable (std::string str_Name, int32_t nValue, OTVariable_Access theAccess=Var_Persistent)
EXPORT	OTVariable (std::string str_Name, bool bValue, OTVariable_Access theAccess=Var_Persistent)
EXPORT	OTVariable (std::string str_Name, std::string str_Value, OTVariable_Access theAccess=Var_Persistent)
virtual EXPORT	~OTVariable ()
void	Serialize (OTString &strAppend, bool bCalculatingID=false) const

Detailed Description

Definition at line 145 of file OTVariable.hpp.

Member Enumeration Documentation

enum opentxs::OTVariable::OTVariable_Access

Enumerator
Var_Constant
Var_Persistent
Var_Important
Var_Error_Access

Definition at line 155 of file OTVariable.hpp.

                           {
        Var_Constant,    // Constant   -- you cannot change this value.
        Var_Persistent,  // Persistent -- changing value doesn't require notice
                         // to parties.
        Var_Important,   // Important  -- changing value requires notice to
                         // parties.
        Var_Error_Access // should never happen.
    };

enum opentxs::OTVariable::OTVariable_Type

Enumerator
Var_String
Var_Integer
Var_Bool
Var_Error_Type

Definition at line 148 of file OTVariable.hpp.

                         {
        Var_String,    // std::string
        Var_Integer,   // Integer. (For int64_t int32_t: use strings.)
        Var_Bool,      // Boolean. (True / False)
        Var_Error_Type // should never happen.
    };

Constructor & Destructor Documentation

opentxs::OTVariable::OTVariable

(

)

Definition at line 234 of file OTVariable.cpp.

    : m_nValue(0)
    , m_bValue(false)
    , m_nValueBackup(0)
    , m_bValueBackup(false)
    , m_pBylaw(nullptr)
    , m_Type(OTVariable::Var_Error_Type)
    , m_Access(Var_Error_Access)
    , m_pScript(nullptr)
{
}

opentxs::OTVariable::OTVariable	(	std::string	str_Name,
		int32_t	nValue,
		OTVariable_Access	theAccess = Var_Persistent
	)

Definition at line 266 of file OTVariable.cpp.

    : m_strName(str_Name.c_str())
    , m_nValue(nValue)
    , m_bValue(false)
    , m_nValueBackup(nValue)
    , m_bValueBackup(false)
    , m_pBylaw(nullptr)
    , m_Type(OTVariable::Var_Integer)
    , m_Access(theAccess)
    , m_pScript(nullptr)
{
}

opentxs::OTVariable::OTVariable	(	std::string	str_Name,
		bool	bValue,
		OTVariable_Access	theAccess = Var_Persistent
	)

Definition at line 281 of file OTVariable.cpp.

    : m_strName(str_Name.c_str())
    , m_nValue(0)
    , m_bValue(bValue)
    , m_nValueBackup(0)
    , m_bValueBackup(bValue)
    , m_pBylaw(nullptr)
    , m_Type(OTVariable::Var_Bool)
    , m_Access(theAccess)
    , m_pScript(nullptr)
{
}

opentxs::OTVariable::OTVariable	(	std::string	str_Name,
		std::string	str_Value,
		OTVariable_Access	theAccess = Var_Persistent
	)

Definition at line 247 of file OTVariable.cpp.

    : m_strName(str_Name.c_str())
    , m_str_Value(str_Value)
    , m_nValue(0)
    , m_bValue(false)
    , m_str_ValueBackup(str_Value)
    , m_nValueBackup(0)
    , m_bValueBackup(false)
    , m_pBylaw(nullptr)
    , m_Type(OTVariable::Var_String)
    , m_Access(theAccess)
    , m_pScript(nullptr)
{
    if (m_str_Value.empty()) m_str_Value = "";
    if (m_str_ValueBackup.empty()) m_str_ValueBackup = "";
}

opentxs::OTVariable::~OTVariable ( )

virtual

Definition at line 295 of file OTVariable.cpp.

{
    if (nullptr != m_pScript) {
        m_pScript->RemoveVariable(*this);
    }

    m_pScript =
        nullptr; // I wasn't the owner, it was a pointer for convenience only.
    m_pBylaw =
        nullptr; // I wasn't the owner, it was a pointer for convenience only.
}

Member Function Documentation

bool opentxs::OTVariable::Compare

(

OTVariable &

rhs

)

Definition at line 438 of file OTVariable.cpp.

{
    if (!(GetName().Compare(rhs.GetName()))) {
        otOut << "OTVariable::Compare: Names don't match: " << GetName()
              << " / " << rhs.GetName() << " \n";
        return false;
    }
    if (!(GetType() == rhs.GetType())) {
        otOut << "OTVariable::Compare: Type doesn't match: " << GetName()
              << " \n";
        return false;
    }
    if (!(GetAccess() == rhs.GetAccess())) {
        otOut << "OTVariable::Compare: Access types don't match: " << GetName()
              << " \n";
        return false;
    }

    bool bMatch = false;

    switch (GetType()) {
    case OTVariable::Var_Integer:
        bMatch = (GetValueInteger() == rhs.GetValueInteger());
        break;
    case OTVariable::Var_Bool:
        bMatch = (GetValueBool() == rhs.GetValueBool());
        break;
    case OTVariable::Var_String:
        bMatch = (GetValueString().compare(rhs.GetValueString()) == 0);
        break;
    default:
        otErr << "OTVariable::Compare: Unknown type in variable " << m_strName
              << ".\n";
        break;
    }

    return bMatch;
}

bool opentxs::OTVariable::CopyValueBool ( ) const

inline

Definition at line 250 of file OTVariable.hpp.

    {
        return m_bValue;
    }

int32_t opentxs::OTVariable::CopyValueInteger ( ) const

inline

Definition at line 246 of file OTVariable.hpp.

    {
        return m_nValue;
    }

std::string opentxs::OTVariable::CopyValueString ( ) const

inline

Definition at line 254 of file OTVariable.hpp.

    {
        return m_str_Value;
    }

OTVariable_Access opentxs::OTVariable::GetAccess ( ) const

inline

Definition at line 228 of file OTVariable.hpp.

    {
        return m_Access;
    }

EXPORT const OTString& opentxs::OTVariable::GetName ( ) const

inline

Definition at line 220 of file OTVariable.hpp.

    {
        return m_strName;
    } // variable's name as used in a script.

OTVariable_Type opentxs::OTVariable::GetType ( ) const

inline

Definition at line 224 of file OTVariable.hpp.

    {
        return m_Type;
    }

bool& opentxs::OTVariable::GetValueBool ( )

inline

Definition at line 263 of file OTVariable.hpp.

    {
        return m_bValue;
    }

int32_t& opentxs::OTVariable::GetValueInteger ( )

inline

Definition at line 259 of file OTVariable.hpp.

    {
        return m_nValue;
    }

std::string& opentxs::OTVariable::GetValueString ( )

inline

Definition at line 267 of file OTVariable.hpp.

    {
        return m_str_Value;
    }

bool opentxs::OTVariable::IsBool ( ) const

inline

Definition at line 237 of file OTVariable.hpp.

    {
        return (Var_Bool == m_Type);
    }

bool opentxs::OTVariable::IsConstant ( ) const

inline

Definition at line 200 of file OTVariable.hpp.

    {
        return (Var_Constant == m_Access);
    }

bool opentxs::OTVariable::IsDirty

(

)

const

Definition at line 353 of file OTVariable.cpp.

{
    bool bReturnVal = false;

    switch (m_Type) {
    case OTVariable::Var_String:
        if (0 != m_str_Value.compare(m_str_ValueBackup)) // If they do NOT
                                                         // match, then it's
                                                         // dirty.
            bReturnVal = true;
        break;
    case OTVariable::Var_Integer:
        if (m_nValue !=
            m_nValueBackup) // If they do NOT match, then it's dirty.
            bReturnVal = true;
        break;
    case OTVariable::Var_Bool:
        if (m_bValue !=
            m_bValueBackup) // If they do NOT match, then it's dirty.
            bReturnVal = true;
        break;
    default:
        otErr << "OTVariable::IsDirty: Error: unknown type for variable: "
              << m_strName << "\n";
        break;
    }

    return bReturnVal;
}

bool opentxs::OTVariable::IsImportant ( ) const

inline

Definition at line 208 of file OTVariable.hpp.

    {
        return (Var_Important == m_Access);
    }

bool opentxs::OTVariable::IsInteger ( ) const

inline

Definition at line 233 of file OTVariable.hpp.

    {
        return (Var_Integer == m_Type);
    }

bool opentxs::OTVariable::IsPersistent ( ) const

inline

Definition at line 204 of file OTVariable.hpp.

    {
        return ((Var_Persistent == m_Access) || (Var_Important == m_Access));
    } // important vars are persistent, too.

bool opentxs::OTVariable::IsString ( ) const

inline

Definition at line 241 of file OTVariable.hpp.

    {
        return (Var_String == m_Type);
    }

void opentxs::OTVariable::RegisterForExecution

(

OTScript &

theScript

)

Definition at line 424 of file OTVariable.cpp.

{
    SetAsClean(); // so we can check for dirtiness after execution.

    const std::string str_var_name = m_strName.Get();

    theScript.AddVariable(str_var_name, *this);

    m_pScript = &theScript; // So later, if the variable destructs, and
                            // this pointer is set, the variable can
                            // remove itself from the script.
}

void opentxs::OTVariable::Serialize	(	OTString &	strAppend,
		bool	bCalculatingID = false
	)		const

Definition at line 144 of file OTVariable.cpp.

{

    std::string str_access("");

    switch (m_Access) {
    case OTVariable::Var_Constant: // This cannot be changed from inside the
                                   // script.
        str_access = "constant";
        break;
    case OTVariable::Var_Persistent: // This can be changed without notifying
                                     // the parties.
        str_access = "persistent";
        break;
    case OTVariable::Var_Important: // This cannot be changed without notifying
                                    // the parties.
        str_access = "important";
        break;
    default:
        otErr << "OTVariable::Serialize:  ERROR:  Bad variable type.\n";
        break;
    }

    std::string str_type;

    switch (m_Type) {
    case OTVariable::Var_String: {
        str_type = "string";

        if ((false == bCalculatingID) && // we don't serialize the variable's
                                         // value when calculating the
            (m_str_Value.size() > 0))    // owner OTScriptable's ID, since the
                                         // value can change over time.
        {
            OTString strVal(m_str_Value.c_str());
            OTASCIIArmor ascVal(strVal);
            strAppend.Concatenate("<variable\n name=\"%s\"\n"
                                  " value=\"%s\"\n"
                                  " type=\"%s\"\n"
                                  " access=\"%s\" >\n%s</variable>\n\n",
                                  m_strName.Get(), "exists", str_type.c_str(),
                                  str_access.c_str(), ascVal.Get());
        }
        else {
            strAppend.Concatenate("<variable\n name=\"%s\"\n"
                                  " value=\"%s\"\n"
                                  " type=\"%s\"\n"
                                  " access=\"%s\" />\n\n",
                                  m_strName.Get(), "none", // value
                                  str_type.c_str(), str_access.c_str());
        }
    } break;
    case OTVariable::Var_Integer:
        str_type = "integer";
        strAppend.Concatenate(
            "<variable\n name=\"%s\"\n"
            " value=\"%d\"\n"
            " type=\"%s\"\n"
            " access=\"%s\" />\n\n",
            m_strName.Get(),
            bCalculatingID ? 0 : m_nValue, // we don't serialize the variable's
                                           // value when calculating the smart
                                           // contract's ID.
            str_type.c_str(), str_access.c_str());
        break;
    case OTVariable::Var_Bool:
        str_type = "bool";
        strAppend.Concatenate(
            "<variable\n name=\"%s\"\n"
            " value=\"%s\"\n"
            " type=\"%s\"\n"
            " access=\"%s\" />\n\n",
            m_strName.Get(),
            bCalculatingID
                ? "false"
                : (m_bValue ? "true" : "false"), // we don't serialize the
                                                 // variable's value when
                                                 // calculating the smart
                                                 // contract's ID.
            str_type.c_str(),
            str_access.c_str());
        break;
    default:
        otErr
            << "OTVariable::Serialize: Error, Wrong Type -- not serializing.\n";
        break;
    }
}

void opentxs::OTVariable::SetAsClean

(

)

Definition at line 385 of file OTVariable.cpp.

{
    switch (m_Type) {
    case OTVariable::Var_String:
        m_str_ValueBackup = m_str_Value; // Save a copy of the current value, so
                                         // we can check later and see if
                                         // they're different.
        break;
    case OTVariable::Var_Integer:
        m_nValueBackup = m_nValue; // Save a copy of the current value, so we
                                   // can check later and see if they're
                                   // different.
        break;
    case OTVariable::Var_Bool:
        m_bValueBackup = m_bValue; // Save a copy of the current value, so we
                                   // can check later and see if they're
                                   // different.
        break;
    default:
        otErr << "OTVariable::SetAsClean: Error: unknown type for variable: "
              << m_strName << "\n";
        m_str_ValueBackup = m_str_Value;
        m_nValueBackup = m_nValue;
        m_bValueBackup = m_bValue;
        break;
    }
}

void opentxs::OTVariable::SetBylaw ( OTBylaw &  theBylaw )

inline

Definition at line 212 of file OTVariable.hpp.

    {
        m_pBylaw = &theBylaw;
    }

bool opentxs::OTVariable::SetValue

(

const int32_t &

nValue

)

Definition at line 307 of file OTVariable.cpp.

{
    if (!IsInteger()) {
        otErr << "OTVariable::SetValue(int64_t): Error: This variable ("
              << m_strName << ") is not an integer.\n";
        return false;
    }

    m_nValue = m_nValueBackup = nValue;

    return true;
}

bool opentxs::OTVariable::SetValue

(

bool

bValue

)

Definition at line 320 of file OTVariable.cpp.

{
    if (!IsBool()) {
        otErr << "OTVariable::SetValue(bool): Error: This variable ("
              << m_strName << ") is not a bool.\n";
        return false;
    }

    m_bValue = m_bValueBackup = bValue;

    return true;
}

bool opentxs::OTVariable::SetValue

(

const std::string &

str_Value

)

Definition at line 333 of file OTVariable.cpp.

{
    if (!IsString()) {
        otErr << "OTVariable::SetValue(std::string): Error: This variable ("
              << m_strName << ") is not a string.\n";
        return false;
    }

    m_str_Value = m_str_ValueBackup = str_Value;

    if (m_str_Value.empty()) m_str_Value = "";
    if (m_str_ValueBackup.empty()) m_str_ValueBackup = "";

    return true;
}

void opentxs::OTVariable::UnregisterScript

(

)

Definition at line 416 of file OTVariable.cpp.

{
    m_pScript = nullptr;
}

---

The documentation for this class was generated from the following files:

• /usr/local/src/opentxs/include/opentxs/core/script/OTVariable.hpp
• /usr/local/src/opentxs/src/core/script/OTVariable.cpp