615 lines
20 KiB
C++
615 lines
20 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: CItemSelectionCriteria, which serves as a criteria for selection
|
|
// of a econ item
|
|
//
|
|
//=============================================================================
|
|
|
|
|
|
#include "cbase.h"
|
|
#include "item_selection_criteria.h"
|
|
|
|
#include "gcsdk/gcsystemmsgs.h"
|
|
|
|
#if defined(TF_CLIENT_DLL) || defined(TF_DLL)
|
|
#include "tf_gcmessages.h"
|
|
#endif
|
|
|
|
#include "gcsdk/enumutils.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
// copied from \common\econ_item_view.h
|
|
#define AE_USE_SCRIPT_VALUE 9999 // Can't be -1, due to unsigned ints used on the backend
|
|
|
|
ENUMSTRINGS_START( EItemCriteriaOperator )
|
|
{ k_EOperator_String_EQ, "string==" },
|
|
{ k_EOperator_String_Not_EQ, "!string==" },
|
|
{ k_EOperator_Float_EQ, "float==" },
|
|
{ k_EOperator_Float_Not_EQ, "!float==" },
|
|
{ k_EOperator_Float_LT, "float<" },
|
|
{ k_EOperator_Float_Not_LT, "!float<" },
|
|
{ k_EOperator_Float_LTE, "float<=" },
|
|
{ k_EOperator_Float_Not_LTE, "!float<=" },
|
|
{ k_EOperator_Float_GT, "float>" },
|
|
{ k_EOperator_Float_Not_GT, "!float>" },
|
|
{ k_EOperator_Float_GTE, "float>=" },
|
|
{ k_EOperator_Float_Not_GTE, "!float>=" },
|
|
{ k_EOperator_Subkey_Contains, "contains" },
|
|
{ k_EOperator_Subkey_Not_Contains, "!contains" },
|
|
ENUMSTRINGS_REVERSE( EItemCriteriaOperator, k_EItemCriteriaOperator_Count )
|
|
|
|
using namespace GCSDK;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Copy Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CItemSelectionCriteria::CItemSelectionCriteria( const CItemSelectionCriteria &that )
|
|
{
|
|
(*this) = that;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Operator=
|
|
//-----------------------------------------------------------------------------
|
|
CItemSelectionCriteria &CItemSelectionCriteria::operator=( const CItemSelectionCriteria &rhs )
|
|
{
|
|
|
|
// Leverage the serialization code we already have for the copy
|
|
CSOItemCriteria msgTemp;
|
|
rhs.BSerializeToMsg( msgTemp );
|
|
BDeserializeFromMsg( msgTemp );
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor
|
|
//-----------------------------------------------------------------------------
|
|
CItemSelectionCriteria::~CItemSelectionCriteria( void )
|
|
{
|
|
m_vecConditions.PurgeAndDeleteElements();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Look through our conditions and find the first of the specified type,
|
|
// and return the value it's looking for.
|
|
//-----------------------------------------------------------------------------
|
|
const char *CItemSelectionCriteria::GetValueForFirstConditionOfType( EItemCriteriaOperator eType ) const
|
|
{
|
|
// Only supporting this for string conditions right now
|
|
Assert( eType == k_EOperator_String_EQ || eType == k_EOperator_String_Not_EQ );
|
|
|
|
FOR_EACH_VEC( m_vecConditions, i )
|
|
{
|
|
if ( m_vecConditions[i]->GetEOp() == eType )
|
|
return m_vecConditions[i]->GetValue();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Look through our conditions and find the first of the specified type,
|
|
// and return the value it's looking for.
|
|
//-----------------------------------------------------------------------------
|
|
const char *CItemSelectionCriteria::GetFieldForFirstConditionOfType( EItemCriteriaOperator eType ) const
|
|
{
|
|
FOR_EACH_VEC( m_vecConditions, i )
|
|
{
|
|
if ( m_vecConditions[i]->GetEOp() == eType )
|
|
return m_vecConditions[i]->GetField();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initialize from a KV structure
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::BInitFromKV( KeyValues *pKVCriteria )
|
|
{
|
|
// Read in the base fields
|
|
if ( pKVCriteria->FindKey( "level" ) )
|
|
{
|
|
SetItemLevel( pKVCriteria->GetInt( "level" ) );
|
|
}
|
|
|
|
if ( pKVCriteria->FindKey( "quality" ) )
|
|
{
|
|
uint8 nQuality;
|
|
if ( !GetItemSchema()->BGetItemQualityFromName( pKVCriteria->GetString( "quality" ), &nQuality ) )
|
|
return false;
|
|
|
|
SetQuality( nQuality );
|
|
}
|
|
|
|
if ( pKVCriteria->FindKey( "inventoryPos" ) )
|
|
{
|
|
SetInitialInventory( pKVCriteria->GetInt( "inventoryPos" ) );
|
|
}
|
|
|
|
if ( pKVCriteria->FindKey( "quantity" ) )
|
|
{
|
|
SetInitialQuantity( pKVCriteria->GetInt( "quantity" ) );
|
|
}
|
|
|
|
if ( pKVCriteria->FindKey( "ignore_enabled" ) )
|
|
{
|
|
SetIgnoreEnabledFlag( pKVCriteria->GetBool( "ignore_enabled" ) );
|
|
}
|
|
|
|
if ( pKVCriteria->FindKey( "tags" ) )
|
|
{
|
|
SetTags( pKVCriteria->GetString( "tags" ) );
|
|
}
|
|
|
|
KeyValues *pKVConditions = pKVCriteria->FindKey( "conditions", true );
|
|
|
|
FOR_EACH_TRUE_SUBKEY( pKVConditions, pKVElement )
|
|
{
|
|
// Check for required fields
|
|
if ( !pKVElement->FindKey( "field" ) ||
|
|
!pKVElement->FindKey( "operator" ) ||
|
|
!pKVElement->FindKey( "value" ) )
|
|
return false;
|
|
|
|
const char *pszField = pKVElement->GetString( "field" );
|
|
bool bRequired = pKVElement->GetBool( "required" );
|
|
const char *pszValue = pKVElement->GetString( "value" );
|
|
|
|
// Get the operator
|
|
const char *pszOperator = pKVElement->GetString( "operator" );
|
|
EItemCriteriaOperator eOp = EItemCriteriaOperatorFromName( pszOperator );
|
|
if ( k_EItemCriteriaOperator_Count == eOp )
|
|
return false;
|
|
|
|
BAddCondition( pszField, eOp, pszValue, bRequired );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItemSelectionCriteria::SetTags( const char *pszTags )
|
|
{
|
|
m_vecTags.Purge();
|
|
|
|
m_strTags = pszTags;
|
|
CSplitString splitString( pszTags, " " );
|
|
for ( int i=0; i<splitString.Count(); ++i )
|
|
{
|
|
econ_tag_handle_t tagHandle = GetItemSchema()->GetHandleForTag( splitString[i] );
|
|
if ( !m_vecTags.HasElement( tagHandle ) )
|
|
{
|
|
m_vecTags.AddToTail( tagHandle );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::BAddCondition( CItemSelectionCriteria::ICondition *pCondition )
|
|
{
|
|
CPlainAutoPtr<ICondition> pConditionPtr( pCondition );
|
|
|
|
// Check for condition limit
|
|
if ( UCHAR_MAX == GetConditionsCount() )
|
|
{
|
|
AssertMsg( false, "Too many conditions on a a CItemSelectionCriteria. Max: 255" );
|
|
return false;
|
|
}
|
|
|
|
m_vecConditions.AddToTail( pConditionPtr.Detach() );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a condition to the selection criteria
|
|
// Input: pszField - Field to evaluate on
|
|
// eOp - Operator to apply to the value of the field
|
|
// flValue - The value to compare.
|
|
// bRequired - When true, causes BEvauluate to fail if pszField doesn't
|
|
// exist in the KV being checked.
|
|
// Output: True if the condition was added, false otherwise
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::BAddCondition( const char *pszField, EItemCriteriaOperator eOp, float flValue, bool bRequired )
|
|
{
|
|
// Enforce maximum string lengths
|
|
if ( Q_strlen( pszField ) >= k_cchCreateItemLen )
|
|
return false;
|
|
|
|
// Create the appropriate condition for the operator
|
|
switch ( eOp )
|
|
{
|
|
case k_EOperator_Float_EQ:
|
|
case k_EOperator_Float_Not_EQ:
|
|
case k_EOperator_Float_LT:
|
|
case k_EOperator_Float_Not_LT:
|
|
case k_EOperator_Float_LTE:
|
|
case k_EOperator_Float_Not_LTE:
|
|
case k_EOperator_Float_GT:
|
|
case k_EOperator_Float_Not_GT:
|
|
case k_EOperator_Float_GTE:
|
|
case k_EOperator_Float_Not_GTE:
|
|
return BAddCondition( new CFloatCondition( pszField, eOp, flValue, bRequired ) );
|
|
|
|
default:
|
|
AssertMsg1( false, "Bad operator (%d) passed to BAddCondition. Float based operator required for this overload.", eOp );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a condition to the selection criteria
|
|
// Input: pszField - Field to evaluate on
|
|
// eOp - Operator to apply to the value of the field
|
|
// pszValue - The value to compare.
|
|
// bRequired - When true, causes BEvauluate to fail if pszField doesn't
|
|
// exist in the KV being checked.
|
|
// Output: True if the condition was added, false otherwise
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::BAddCondition( const char *pszField, EItemCriteriaOperator eOp, const char * pszValue, bool bRequired )
|
|
{
|
|
// Enforce maximum string lengths
|
|
if ( Q_strlen( pszField ) >= k_cchCreateItemLen || Q_strlen( pszValue ) >= k_cchCreateItemLen )
|
|
return false;
|
|
|
|
// Create the appropriate condition for the operator
|
|
switch ( eOp )
|
|
{
|
|
case k_EOperator_String_EQ:
|
|
case k_EOperator_String_Not_EQ:
|
|
return BAddCondition( new CStringCondition( pszField, eOp, pszValue, bRequired ) );
|
|
return true;
|
|
|
|
case k_EOperator_Subkey_Contains:
|
|
case k_EOperator_Subkey_Not_Contains:
|
|
return BAddCondition( new CSetCondition( pszField, eOp, pszValue, bRequired ) );
|
|
return true;
|
|
|
|
default:
|
|
// Try the float operators
|
|
return BAddCondition( pszField, eOp, Q_atof( pszValue ), bRequired );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks if a given item matches the item selection criteria
|
|
// Input: itemDef - The item definition to evaluate against
|
|
// Output: True is the item passes the filter, false otherwise
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::BEvaluate( const CEconItemDefinition* pItemDef ) const
|
|
{
|
|
// Disabled items never match
|
|
if ( !m_bIgnoreEnabledFlag && !pItemDef->BEnabled() )
|
|
return false;
|
|
|
|
// Filter against level
|
|
if ( BItemLevelSet() && (GetItemLevel() != AE_USE_SCRIPT_VALUE) &&
|
|
( GetItemLevel() < pItemDef->GetMinLevel() || GetItemLevel() > pItemDef->GetMaxLevel() ) )
|
|
return false;
|
|
|
|
// Filter against quality
|
|
if ( BQualitySet() && (GetQuality() != AE_USE_SCRIPT_VALUE) )
|
|
{
|
|
if ( GetQuality() != pItemDef->GetQuality() )
|
|
{
|
|
// Filter out item defs that have a non-any quality if we have a non-matching & non-any quality criteria
|
|
if ( k_unItemQuality_Any != GetQuality() && k_unItemQuality_Any != pItemDef->GetQuality() )
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Filter against the additional conditions
|
|
FOR_EACH_VEC( m_vecConditions, i )
|
|
{
|
|
if ( !m_vecConditions[i]->BItemDefinitionPassesCriteria( pItemDef ) )
|
|
return false;
|
|
}
|
|
|
|
// Check if we have "any" tags
|
|
if ( m_vecTags.Count() > 0 )
|
|
{
|
|
bool bHasTag = false;
|
|
FOR_EACH_VEC( m_vecTags, i )
|
|
{
|
|
if ( pItemDef->HasEconTag( m_vecTags[i] ) )
|
|
{
|
|
bHasTag = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !bHasTag )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines if the item matches this condition of the criteria
|
|
// Input: pKVItem - Pointer to the raw KeyValues definition of the item
|
|
// Output: True is the item matches, false otherwise
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::CCondition::BEvaluate( KeyValues *pKVItem ) const
|
|
{
|
|
KeyValues *pKVField = pKVItem->FindKey( m_sField.String() );
|
|
|
|
// Treat an empty string as a missing field as well.
|
|
bool bIsEmptyString = false;
|
|
if ( m_EOp == k_EOperator_String_EQ || m_EOp == k_EOperator_String_Not_EQ )
|
|
{
|
|
const char *pszItemVal = pKVField ? pKVField->GetString() : NULL;
|
|
bIsEmptyString = ( pszItemVal == NULL || pszItemVal[0] == '\0' );
|
|
}
|
|
|
|
// Deal with missing fields
|
|
if ( NULL == pKVField || bIsEmptyString )
|
|
{
|
|
if ( m_bRequired )
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
// Run the operator specific check
|
|
bool bRet = BInternalEvaluate( pKVItem );
|
|
|
|
// If this is a "not" operator, reverse the result
|
|
if ( m_EOp & k_EOperator_Not )
|
|
return !bRet;
|
|
else
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Runs the operator specific check for this condition
|
|
// Input: pKVItem - Pointer to the raw KeyValues definition of the item
|
|
// Output: True is the item matches, false otherwise
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::CStringCondition::BInternalEvaluate( KeyValues *pKVItem ) const
|
|
{
|
|
Assert( k_EOperator_String_EQ == m_EOp || k_EOperator_String_Not_EQ == m_EOp );
|
|
if( !( k_EOperator_String_EQ == m_EOp || k_EOperator_String_Not_EQ == m_EOp ) )
|
|
return false;
|
|
|
|
const char *pszItemVal = pKVItem->GetString( m_sField.String() );
|
|
return ( 0 == Q_stricmp( m_sValue.String(), pszItemVal ) );
|
|
}
|
|
|
|
bool CItemSelectionCriteria::CStringCondition::BSerializeToMsg( CSOItemCriteriaCondition & msg ) const
|
|
{
|
|
CCondition::BSerializeToMsg( msg );
|
|
msg.set_string_value( m_sValue.Get() );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Runs the operator specific check for this condition
|
|
// Input: pKVItem - Pointer to the raw KeyValues definition of the item
|
|
// Output: True is the item matches, false otherwise
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::CSetCondition::BInternalEvaluate( KeyValues *pKVItem ) const
|
|
{
|
|
Assert( k_EOperator_Subkey_Contains == m_EOp || k_EOperator_Subkey_Not_Contains == m_EOp );
|
|
if( !( k_EOperator_Subkey_Contains == m_EOp || k_EOperator_Subkey_Not_Contains == m_EOp ) )
|
|
return false;
|
|
|
|
return ( NULL != pKVItem->FindKey( m_sField.String() )->FindKey( m_sValue.String() ) );
|
|
}
|
|
|
|
bool CItemSelectionCriteria::CSetCondition::BSerializeToMsg( CSOItemCriteriaCondition & msg ) const
|
|
{
|
|
CCondition::BSerializeToMsg( msg );
|
|
msg.set_string_value( m_sValue.Get() );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Runs the operator specific check for this condition
|
|
// Input: pKVItem - Pointer to the raw KeyValues definition of the item
|
|
// Output: True is the item matches, false otherwise
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::CFloatCondition::BInternalEvaluate( KeyValues *pKVItem ) const
|
|
{
|
|
float itemValue = pKVItem->GetFloat( m_sField.String() );
|
|
|
|
switch ( m_EOp )
|
|
{
|
|
case k_EOperator_Float_EQ:
|
|
case k_EOperator_Float_Not_EQ:
|
|
return ( itemValue == m_flValue );
|
|
|
|
case k_EOperator_Float_LT:
|
|
case k_EOperator_Float_Not_LT:
|
|
return ( itemValue < m_flValue );
|
|
|
|
case k_EOperator_Float_LTE:
|
|
case k_EOperator_Float_Not_LTE:
|
|
return ( itemValue <= m_flValue );
|
|
|
|
case k_EOperator_Float_GT:
|
|
case k_EOperator_Float_Not_GT:
|
|
return ( itemValue > m_flValue );
|
|
|
|
case k_EOperator_Float_GTE:
|
|
case k_EOperator_Float_Not_GTE:
|
|
return ( itemValue >= m_flValue );
|
|
|
|
default:
|
|
AssertMsg1( false, "Unknown operator: %d", m_EOp );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CItemSelectionCriteria::CFloatCondition::BSerializeToMsg( CSOItemCriteriaCondition & msg ) const
|
|
{
|
|
CCondition::BSerializeToMsg( msg );
|
|
msg.set_float_value( m_flValue );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Serialize the item selection criteria to the given message
|
|
// Input: msg - The message to serialize to.
|
|
// Output: True if the operation was successful, false otherwise.
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::BSerializeToMsg( CSOItemCriteria & msg ) const
|
|
{
|
|
msg.set_item_level( m_unItemLevel );
|
|
msg.set_item_quality( m_nItemQuality );
|
|
msg.set_item_level_set( m_bItemLevelSet );
|
|
msg.set_item_quality_set( m_bQualitySet );
|
|
msg.set_initial_inventory( m_unInitialInventory );
|
|
msg.set_initial_quantity( m_unInitialQuantity );
|
|
msg.set_ignore_enabled_flag( m_bIgnoreEnabledFlag );
|
|
msg.set_tags( m_strTags );
|
|
|
|
FOR_EACH_VEC( m_vecConditions, i )
|
|
{
|
|
CSOItemCriteriaCondition *pConditionMsg = msg.add_conditions();
|
|
m_vecConditions[i]->BSerializeToMsg( *pConditionMsg );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Deserializes the item selection criteria from the given message
|
|
// Input: msg - The message to deserialize from.
|
|
// Output: True if the operation was successful, false otherwise.
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::BDeserializeFromMsg( const CSOItemCriteria & msg )
|
|
{
|
|
m_unItemLevel = msg.item_level();
|
|
m_nItemQuality = msg.item_quality();
|
|
m_bItemLevelSet = msg.item_level_set();
|
|
m_bQualitySet = msg.item_quality_set();
|
|
m_unInitialInventory = msg.initial_inventory();
|
|
m_unInitialQuantity = msg.initial_quantity();
|
|
m_bIgnoreEnabledFlag = msg.ignore_enabled_flag();
|
|
|
|
SetTags( msg.tags().c_str() );
|
|
|
|
uint32 unCount = msg.conditions_size();
|
|
m_vecConditions.EnsureCapacity( unCount );
|
|
|
|
for ( uint32 i = 0; i < unCount; i++ )
|
|
{
|
|
const CSOItemCriteriaCondition & cond = msg.conditions( i );
|
|
EItemCriteriaOperator eOp = (EItemCriteriaOperator)cond.op();
|
|
bool bRequired = cond.required();
|
|
|
|
// Read the value specific to the condition and add the condition
|
|
switch ( eOp )
|
|
{
|
|
case k_EOperator_Float_EQ:
|
|
case k_EOperator_Float_Not_EQ:
|
|
case k_EOperator_Float_LT:
|
|
case k_EOperator_Float_Not_LT:
|
|
case k_EOperator_Float_LTE:
|
|
case k_EOperator_Float_Not_LTE:
|
|
case k_EOperator_Float_GT:
|
|
case k_EOperator_Float_Not_GT:
|
|
case k_EOperator_Float_GTE:
|
|
case k_EOperator_Float_Not_GTE:
|
|
{
|
|
if ( !BAddCondition( cond.field().c_str(), eOp, cond.float_value(), bRequired ) ) return false;
|
|
break;
|
|
}
|
|
|
|
case k_EOperator_String_EQ:
|
|
case k_EOperator_String_Not_EQ:
|
|
case k_EOperator_Subkey_Contains:
|
|
case k_EOperator_Subkey_Not_Contains:
|
|
{
|
|
if ( !BAddCondition( cond.field().c_str(), eOp, cond.string_value().c_str(), bRequired ) ) return false;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
AssertMsg1( false, "Unknown operator (%d) read.", eOp );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Serializes a condition to a message.
|
|
// Input: msg - The message to serialize to.
|
|
// Output: True if the operation was successful, false otherwise.
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::CCondition::BSerializeToMsg( CSOItemCriteriaCondition & msg ) const
|
|
{
|
|
msg.set_op( m_EOp );
|
|
msg.set_field( m_sField.String() );
|
|
msg.set_required( m_bRequired );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CItemSelectionCriteria::CCondition::BItemDefinitionPassesCriteria( const CEconItemDefinition *pItemDef ) const
|
|
{
|
|
return BEvaluate( pItemDef->GetRawDefinition() );
|
|
}
|
|
|
|
// Validation
|
|
#ifdef DBGFLAG_VALIDATE
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Run a global validation pass on all of our data structures and memory
|
|
// allocations.
|
|
// Input: validator - Our global validator object
|
|
// pchName - Our name (typically a member var in our container)
|
|
//-----------------------------------------------------------------------------
|
|
void CItemSelectionCriteria::Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
ValidateObj( m_vecConditions );
|
|
FOR_EACH_VEC( m_vecConditions, i )
|
|
{
|
|
ValidatePtr( m_vecConditions[i] );
|
|
}
|
|
}
|
|
|
|
void CItemSelectionCriteria::CCondition::Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
ValidateObj( m_sField );
|
|
}
|
|
|
|
void CItemSelectionCriteria::CStringCondition::Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
CCondition::Validate( validator, pchName );
|
|
ValidateObj( m_sValue );
|
|
}
|
|
|
|
void CItemSelectionCriteria::CSetCondition::Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
CCondition::Validate( validator, pchName );
|
|
ValidateObj( m_sValue );
|
|
}
|
|
|
|
#endif
|