VRUT::Environment Class Reference

Environment for registered parameters management class. More...

#include <environment.h>

List of all members.

Public Types

typedef std::pair< wxString,
wxString > 		NameValue

Public Member Functions

 Environment ()
 Class constructor.
 ~Environment ()
 Class destructor.
wxString GetParam (const Parameter::ParameterIdentificator &paramId) const
void GetParams (const Parameter::ParameterIdentificator &paramId, std::vector< NameValue > *values) const
bool SetParam (const Parameter::ParameterIdentificator &paramId, const wxString &value, bool forceDefault=false)
bool RegisterParam (const Parameter::ParameterIdentificator &paramId, const wxString &value)
bool UnregisterParam (const Parameter::ParameterIdentificator &paramId)
void ApplyPendingParams (Module *module, const wxString altName=wxEmptyString)

Protected Member Functions

 WX_DECLARE_STRING_HASH_MAP (Parameter, InstParamList)
 Hash map type mapping instance (usually module instance) identificator to list of parameters registered for this instance.
 WX_DECLARE_STRING_HASH_MAP (InstParamList, NameInstParamList)
 Hash map type mapping parameter name to instance list of parameters registered.
 WX_DECLARE_STRING_HASH_MAP (NameInstParamList, PoolNameInstParamList)
 Hash map type mapping pool identificator (usually module's name) to list of parameters registered.

Protected Attributes

PoolNameInstParamList registeredParameters
 Hash map mapping pool identificator (usually module's name) to list of parameters registered.

Detailed Description

Environment for registered parameters management class.

Definition at line 152 of file environment.h.

Member Typedef Documentation

typedef std::pair<wxString, wxString> VRUT::Environment::NameValue

Definition at line 166 of file environment.h.

Constructor & Destructor Documentation

Environment::Environment (  ) 

Class constructor.

Definition at line 19 of file environment.cpp.

00020 {
00021 }

Environment::~Environment (  ) 

Class destructor.

Definition at line 24 of file environment.cpp.

00025 {
00026 }

Member Function Documentation

VRUT::Environment::WX_DECLARE_STRING_HASH_MAP ( Parameter  ,
InstParamList   
) [protected]

Hash map type mapping instance (usually module instance) identificator to list of parameters registered for this instance.

VRUT::Environment::WX_DECLARE_STRING_HASH_MAP ( InstParamList  ,
NameInstParamList   
) [protected]

Hash map type mapping parameter name to instance list of parameters registered.

VRUT::Environment::WX_DECLARE_STRING_HASH_MAP ( NameInstParamList  ,
PoolNameInstParamList   
) [protected]

Hash map type mapping pool identificator (usually module's name) to list of parameters registered.

wxString Environment::GetParam ( const Parameter::ParameterIdentificator &  paramId  )  const

Get parameter value as string, much faster than GetParams

Parameters:
[in] paramId Parameter identificator of registered parameter, '*' and '?' NOT allowed
Returns:
Value as string if found, empty string otherwise

Definition at line 29 of file environment.cpp.

00030 {
00031        PoolNameInstParamList::const_iterator poolIt = registeredParameters.find(paramId.poolName);
00032        if (poolIt != registeredParameters.end())
00033        {
00034               NameInstParamList::const_iterator paramIt = poolIt->second.find(paramId.paramName);
00035               if (paramIt != poolIt->second.end())
00036               {
00037                      InstParamList::const_iterator instIt = paramIt->second.find(paramId.instName);
00038                      if (instIt != paramIt->second.end())
00039                             return instIt->second.value;
00040               }
00041        }
00042 
00043        return wxEmptyString;
00044 }

void Environment::GetParams ( const Parameter::ParameterIdentificator &  paramId,
std::vector< NameValue > *  values 
) const

Get parameter(s') value(s) as string

Parameters:
[in] paramId Parameter identificator of registered parameter(s), '*' and '?' allowed in all members
[out] values Filled with full parameter names (first) and its values (second)

Definition at line 47 of file environment.cpp.

00048 {
00049        if (!values)
00050               return;
00051 
00052        for (PoolNameInstParamList::const_iterator poolIt = registeredParameters.begin();
00053                poolIt != registeredParameters.end(); poolIt++)
00054        {
00055               wxString poolName = poolIt->first;
00056               if (poolName.Upper().Matches(paramId.poolName.Upper()))
00057               {
00058                      for (NameInstParamList::const_iterator parIt = poolIt->second.begin();
00059                              parIt != poolIt->second.end(); parIt++)
00060                      {
00061                             wxString parName = parIt->first;
00062                             if (parName.Upper().Matches(paramId.paramName.Upper()))
00063                             {
00064                                    for (InstParamList::const_iterator instIt = parIt->second.begin();
00065                                            instIt != parIt->second.end(); instIt++)
00066                                    {
00067                                           wxString instName = instIt->first;
00068                                           if (instName.Upper().Matches(paramId.instName.Upper()))
00069                                           {
00070                                                  Parameter::ParameterIdentificator pi(poolName, parName, instName);
00071                                                  NameValue ret(pi.ToString(), CloneWxString(instIt->second.value));
00072                                                  values->push_back(ret);
00073                                           }
00074                                    }
00075                             }
00076                      }
00077               }
00078        }
00079 }

bool Environment::SetParam ( const Parameter::ParameterIdentificator &  paramId,
const wxString &  value,
bool  forceDefault = false 
)

Set parameter value and/or its default, will be applied to all matches Given parameter is registered if no match found and paramId.poolName and paramId.paramName have no '?','*' characters

Parameters:
[in] paramId Parameter identificator of registered parameter(s), '*' and '?' allowed in all members
[in] value New value as string
[in] forceDefault Value will be assigned as default for this parameter
Returns:
true if any match found, false otherwise (doesn't mean neccessarily that parameter was registered)

Register new parameter if conditions are met

Definition at line 82 of file environment.cpp.

00083 {
00084        bool found = false;
00085 
00086        for (PoolNameInstParamList::iterator poolIt = registeredParameters.begin();
00087                poolIt != registeredParameters.end(); poolIt++)
00088        {
00089               wxString poolName = poolIt->first;
00090               if (poolName.Upper().Matches(paramId.poolName.Upper()))
00091               {
00092                      for (NameInstParamList::iterator parIt = poolIt->second.begin();
00093                              parIt != poolIt->second.end(); parIt++)
00094                      {
00095                             wxString parName = parIt->first;
00096                             if (parName.Upper().Matches(paramId.paramName.Upper()))
00097                             {
00098                                    for (InstParamList::iterator instIt = parIt->second.begin();
00099                                            instIt != parIt->second.end(); instIt++)
00100                                    {
00101                                           wxString instName = instIt->first;
00102                                           if (instName.Upper().Matches(paramId.instName.Upper()))
00103                                           {
00104                                                  Parameter::ParameterIdentificator pi(poolName, parName, instName);
00105                                                  if (forceDefault && instIt->second.defaultValue != value)
00106                                                         instIt->second.defaultValue = CloneWxString(value);
00107                                                  //if (instIt->second.value != value)
00108                                                  {
00109                                                         instIt->second.value = CloneWxString(value);
00110                                                         wxCommandEvent paramEvt = Event::GET_EVT_PARAM_SET(pi, value);
00111                                                         KERNEL->GetMessageSink()->PostEvent(paramEvt);
00112                                                         LOGVERBOSE(wxString::Format(wxT("<Environment>%s = %s"), pi.ToString().c_str(), value.c_str()));
00113                                                  }
00114                                                  found = true;
00115                                           }
00116                                    }
00117                             }
00118                      }
00119               }
00120        }
00121 
00123        if (!found && !RegisterParam(paramId, value))
00124               LOGERROR(wxString::Format(wxT("<Environment>Parameter '%s' not found and not valid to register"), paramId.ToString().c_str()));
00125 
00126        return found;
00127 }

bool Environment::RegisterParam ( const Parameter::ParameterIdentificator &  paramId,
const wxString &  value 
)

Register new parameter

Parameters:
[in] paramId Parameter full identificator
[in] value Default value
Returns:
true if successful

Get instance name - 'predef' by default, assuming predefinition from startup script or command line

If found the value has higher priority (cmdline argument or script command) and we don't want to overwrite it with value given with register call. So we do nothing

Definition at line 130 of file environment.cpp.

00131 {
00132        if (paramId.IsValid())
00133        {
00135               wxString instNameExact = wxT("predef");
00136               if ((paramId.instName.Find('*') == wxNOT_FOUND)
00137                       && (paramId.instName.Find('?') == wxNOT_FOUND)
00138                       && !paramId.instName.IsEmpty())
00139                      instNameExact = CloneWxString(paramId.instName);
00140 
00141               Parameter parameter(value, value);
00142               InstParamList ipl;
00143               ipl.insert(InstParamList::value_type(instNameExact, parameter));
00144 
00145               PoolNameInstParamList::iterator poolIt = registeredParameters.find(paramId.poolName);
00146               if (poolIt == registeredParameters.end())
00147               {
00148                      NameInstParamList nipl;
00149                      nipl.insert(NameInstParamList::value_type(CloneWxString(paramId.paramName), ipl));
00150                      registeredParameters.insert(PoolNameInstParamList::value_type(CloneWxString(paramId.poolName), nipl));
00151               }
00152               else
00153               {
00154                      NameInstParamList::iterator paramIt = poolIt->second.find(paramId.paramName);
00155                      if (paramIt == poolIt->second.end())
00156                             poolIt->second.insert(NameInstParamList::value_type(CloneWxString(paramId.paramName), ipl));
00157                      else
00158                      {
00159                             InstParamList::iterator instIt = paramIt->second.find(instNameExact);
00160                             if (instIt == paramIt->second.end())
00161                                    paramIt->second.insert(InstParamList::value_type(instNameExact, parameter));
00162                             else
00163                             {
00167                                    return false;
00168                             }
00169                      }
00170               }
00171               Parameter::ParameterIdentificator pi(paramId.poolName, paramId.paramName, instNameExact);
00172               LOGVERBOSE(wxString::Format(wxT("<Environment>Registered %s = %s"), pi.ToString().c_str(), value.c_str()));
00173               return true;
00174        }
00175        return false;
00176 }

bool Environment::UnregisterParam ( const Parameter::ParameterIdentificator &  paramId  ) 

Unregister parameter

Parameters:
[in] paramId paramId Parameter identificator of registered parameter(s), '*' and '?' allowed (not in poolName member)
Returns:
true if successful

Definition at line 179 of file environment.cpp.

00180 {
00181        bool found = false;
00182 
00183        PoolNameInstParamList::iterator poolIt = registeredParameters.find(paramId.poolName);
00184        if (poolIt != registeredParameters.end())
00185        {
00186               std::vector<NameInstParamList::iterator> forDeletion;
00187               for (NameInstParamList::iterator parIt = poolIt->second.begin();
00188                       parIt != poolIt->second.end(); parIt++)
00189               {
00190                      wxString parName = parIt->first;
00191                      if (parName.Matches(paramId.paramName))
00192                      {
00193                             std::vector<InstParamList::iterator> forDeletionInst;
00194                             for (InstParamList::iterator instIt = parIt->second.begin();
00195                                     instIt != parIt->second.end(); instIt++)
00196                             {
00197                                    wxString instName = instIt->first;
00198                                    if (instName.Matches(paramId.instName)
00199                                           && !instName.IsSameAs(wxT("predef")))
00200                                    {
00201                                           forDeletionInst.push_back(instIt);
00202                                           Parameter::ParameterIdentificator pi(poolIt->first, parName, instName);
00203                                           found = true;
00204                                           LOGVERBOSE(wxString::Format(wxT("<Environment>Unregistered parameter %s"), pi.ToString().c_str()));
00205                                    }
00206                             }
00207                             for (std::vector<InstParamList::iterator>::const_iterator delIt = forDeletionInst.begin();
00208                                    delIt != forDeletionInst.end(); delIt++)
00209                                    parIt->second.erase(*delIt);
00210                             if (parIt->second.empty())
00211                                    forDeletion.push_back(parIt);
00212                      }
00213               }
00214               for (std::vector<NameInstParamList::iterator>::const_iterator delIt = forDeletion.begin();
00215                      delIt != forDeletion.end(); delIt++)
00216                      poolIt->second.erase(*delIt);
00217               if (poolIt->second.empty())
00218                      registeredParameters.erase(poolIt);
00219        }
00220 
00221        return found;
00222 }

void Environment::ApplyPendingParams ( Module *  module,
const wxString  altName = wxEmptyString 
)

Apply pending parameter default values to a module

Parameters:
[in] module Module to apply default values to
[in] altName Alternative module name (for searching)

Check if param exists for this module instance in particular

No param for this instance, try to find a predefinition value

Apply params with highest priority

Post set event (needed to update GUI)

Definition at line 225 of file environment.cpp.

00226 {
00227        bool found = false;
00228        const wxString poolName = module->GetName();
00229        LOGVERBOSE(wxT("<Environment>Applying default parameter values to ") + poolName);
00230        PoolNameInstParamList::const_iterator poolIt = registeredParameters.find(poolName);
00231        if (poolIt == registeredParameters.end() && !altName.IsEmpty())
00232               poolIt = registeredParameters.find(altName);
00233        if (poolIt != registeredParameters.end())
00234        {
00235               for (NameInstParamList::const_iterator parIt = poolIt->second.begin();
00236                       parIt != poolIt->second.end(); parIt++)
00237               {
00239                      wxString instName = wxString::Format(wxT("%i"), module->GetID().GetInstanceID());
00240                      Parameter::ParameterIdentificator pi(poolIt->first, parIt->first, instName);
00241                      InstParamList::const_iterator instIt = parIt->second.find(instName);
00242                      if (instIt == parIt->second.end())
00243                      {
00245                             instIt = parIt->second.find(wxT("predef"));
00246                             if (instIt == parIt->second.end())
00247                                    continue;
00248                             RegisterParam(pi, instIt->second.value);
00249                      }
00250                      found = true;
00251                      wxCommandEvent paramEvt = Event::GET_EVT_PARAM_SET(pi, instIt->second.value);
00253                      module->PostEvent(paramEvt, true);
00255                      wxCommandEvent paramEvt2 = Event::GET_EVT_PARAM_SET(pi, instIt->second.value);
00256                      KERNEL->GetMessageSink()->PostEvent(paramEvt2);
00257                      LOGVERBOSE(wxString::Format(wxT("%s = %s"), pi.ToString().c_str(), instIt->second.value.c_str()));
00258               }
00259        }
00260 
00261        if (!found)
00262               LOGVERBOSE(wxT("<Environment>No default parameter values pending for ") + module->GetName());
00263 }

Member Data Documentation

PoolNameInstParamList VRUT::Environment::registeredParameters [protected]

Hash map mapping pool identificator (usually module's name) to list of parameters registered.

Definition at line 163 of file environment.h.

The documentation for this class was generated from the following files:
Generated on Tue Mar 10 14:41:41 2009 for VRUT by  doxygen 1.5.5