00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014 #include "amp.h"
00015 #include "tag.h"
00016 #include "util.h"
00017
00018 namespace gloox
00019 {
00020
00021 static const char* conditionValues[] =
00022 {
00023 "deliver", "expire-at", "match-resource"
00024 };
00025
00026 static const char* actionValues[] =
00027 {
00028 "alert", "error", "drop", "notify"
00029 };
00030
00031 static const char* deliverValues[] =
00032 {
00033 "direct", "forward", "gateway", "none", "stored"
00034 };
00035
00036 static const char* matchResourceValues[] =
00037 {
00038 "any", "exact", "other"
00039 };
00040
00041 static const char* statusValues[] =
00042 {
00043 "alert", "notify"
00044 };
00045
00046
00047 AMP::Rule::Rule( DeliverType deliver, ActionType action )
00048 : m_condition( ConditionDeliver ), m_deliver( deliver ), m_action( action )
00049 {
00050 }
00051
00052 AMP::Rule::Rule( const std::string& date, ActionType action )
00053 : m_condition( ConditionExpireAt ), m_expireat( new std::string( date ) ), m_action( action )
00054 {
00055 }
00056
00057 AMP::Rule::Rule( MatchResourceType match, ActionType action )
00058 : m_condition( ConditionMatchResource ), m_matchresource( match ), m_action( action )
00059 {
00060 }
00061
00062 AMP::Rule::Rule( const std::string& condition, const std::string& action,
00063 const std::string& value )
00064 {
00065 m_condition = (ConditionType)util::lookup( condition, conditionValues );
00066 m_action = (ActionType)util::lookup( action, actionValues );
00067 switch( m_condition )
00068 {
00069 case ConditionDeliver:
00070 m_deliver = (DeliverType)util::lookup( value, deliverValues );
00071 break;
00072 case ConditionExpireAt:
00073 m_expireat = new std::string( value );
00074 break;
00075 case ConditionMatchResource:
00076 m_matchresource = (MatchResourceType)util::lookup( value, matchResourceValues );
00077 break;
00078 default:
00079 case ConditionInvalid:
00080 break;
00081 }
00082 }
00083
00084 AMP::Rule::~Rule()
00085 {
00086 if( m_condition == ConditionExpireAt && m_expireat )
00087 delete m_expireat;
00088 }
00089
00090 Tag* AMP::Rule::tag() const
00091 {
00092 if( m_condition == ConditionInvalid || m_action == ActionInvalid
00093 || ( m_condition == ConditionDeliver && m_deliver == DeliverInvalid )
00094 || ( m_condition == ConditionMatchResource && m_matchresource == MatchResourceInvalid )
00095 || ( m_condition == ConditionExpireAt && !m_expireat ) )
00096 return 0;
00097
00098 Tag* rule = new Tag( "rule" );
00099 rule->addAttribute( "condition", util::lookup( m_condition, conditionValues ) );
00100 rule->addAttribute( "action", util::lookup( m_action, actionValues ) );
00101
00102 switch( m_condition )
00103 {
00104 case ConditionDeliver:
00105 rule->addAttribute( "value", util::lookup( m_deliver, deliverValues ) );
00106 break;
00107 case ConditionExpireAt:
00108 rule->addAttribute( "value", *m_expireat );
00109 break;
00110 case ConditionMatchResource:
00111 rule->addAttribute( "value", util::lookup( m_matchresource, matchResourceValues ) );
00112 break;
00113 default:
00114 break;
00115 }
00116 return rule;
00117 }
00118
00119
00120
00121 AMP::AMP( bool perhop )
00122 : StanzaExtension( ExtAMP ), m_perhop( perhop ), m_status( StatusInvalid )
00123 {
00124 m_valid = true;
00125 }
00126
00127 AMP::AMP( const Tag* tag )
00128 : StanzaExtension( ExtAMP ), m_perhop( false )
00129 {
00130 if( !tag || tag->name() != "amp" || tag->xmlns() != XMLNS_AMP )
00131 return;
00132
00133 const ConstTagList& rules = tag->findTagList( "/amp/rule" );
00134 ConstTagList::const_iterator it = rules.begin();
00135 for( ; it != rules.end(); ++it )
00136 {
00137 m_rules.push_back( new Rule( (*it)->findAttribute( "condition" ),
00138 (*it)->findAttribute( "action" ),
00139 (*it)->findAttribute( "value" ) ) );
00140 }
00141
00142 m_from = tag->findAttribute( "from" );
00143 m_to = tag->findAttribute( "to" );
00144 m_status = (Status)util::lookup( tag->findAttribute( "status" ), statusValues );
00145 if( tag->hasAttribute( "per-hop", "true" ) || tag->hasAttribute( "per-hop", "1" ) )
00146 m_perhop = true;
00147 m_valid = true;
00148 }
00149
00150 AMP::~AMP()
00151 {
00152 util::clearList( m_rules );
00153 }
00154
00155 void AMP::addRule( const Rule* rule )
00156 {
00157 if( rule )
00158 m_rules.push_back( rule );
00159 }
00160
00161 const std::string& AMP::filterString() const
00162 {
00163 static const std::string filter = "/message/amp[@xmlns='" + XMLNS_AMP + "']";
00164 return filter;
00165 }
00166
00167 Tag* AMP::tag() const
00168 {
00169 if( !m_valid || !m_rules.size() )
00170 return 0;
00171
00172 Tag* amp = new Tag( "amp" );
00173 amp->setXmlns( XMLNS_AMP );
00174 if( m_from )
00175 amp->addAttribute( "from", m_from.full() );
00176 if( m_to )
00177 amp->addAttribute( "to", m_to.full() );
00178 if( m_status != StatusInvalid )
00179 amp->addAttribute( "status", util::lookup( m_status, statusValues ) );
00180 if( m_perhop )
00181 amp->addAttribute( "per-hop", "true" );
00182 RuleList::const_iterator it = m_rules.begin();
00183 for( ; it != m_rules.end(); ++it )
00184 amp->addChild( (*it)->tag() );
00185
00186 return amp;
00187 }
00188
00189 }