TAO: ZIOP_Stub.cpp Source File

Go to the documentation of this file.
00001 // $Id: ZIOP_Stub.cpp 84803 2009-03-12 07:52:59Z msmit $
00002 
00003 #include "tao/ZIOP/ZIOP_Stub.h"
00004 
00005 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
00006 
00007 #include "tao/ZIOP/ZIOP_Policy_i.h"
00008 #include "tao/ZIOP/ZIOP.h"
00009 #include "tao/ORB_Core.h"
00010 #include "tao/Policy_Set.h"
00011 #include "tao/Policy_Manager.h"
00012 #include "tao/SystemException.h"
00013 
00014 ACE_RCSID (ZIOP,
00015            ZIOP_Stub,
00016            "$Id: ZIOP_Stub.cpp 84803 2009-03-12 07:52:59Z msmit $")
00017 
00018 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00019 
00020 TAO_ZIOP_Stub::TAO_ZIOP_Stub (const char *repository_id,
00021                               const TAO_MProfile &profiles,
00022                               TAO_ORB_Core *orb_core)
00023   : TAO_Stub (repository_id,
00024               profiles,
00025               orb_core),
00026     are_policies_parsed_ (false)
00027 {
00028 }
00029 
00030 TAO_ZIOP_Stub::~TAO_ZIOP_Stub (void)
00031 {
00032   if (!CORBA::is_nil (this->compression_enabling_policy_.in ()))
00033     this->compression_enabling_policy_->destroy ();
00034 
00035   if (!CORBA::is_nil (this->compression_id_list_policy_.in ()))
00036     this->compression_id_list_policy_->destroy ();
00037 }
00038 
00039 void
00040 TAO_ZIOP_Stub::parse_policies (void)
00041 {
00042   CORBA::PolicyList_var policy_list
00043     = this->base_profiles_.policy_list ();
00044 
00045   CORBA::ULong const length = policy_list->length ();
00046 
00047   // Cache away the policies that we'll need later.
00048   for (CORBA::ULong i = 0; i < length; ++i)
00049     {
00050       switch (policy_list[i]->policy_type ())
00051         {
00052            case ZIOP::COMPRESSION_ENABLING_POLICY_ID:
00053              {
00054                this->exposed_compression_enabling_policy (policy_list[i]);
00055              }
00056              break;
00057            case ZIOP::COMPRESSOR_ID_LEVEL_LIST_POLICY_ID:
00058              {
00059                this->exposed_compression_id_list_policy (policy_list[i]);
00060              }
00061              break;
00062          }
00063 
00064     }
00065 
00066   this->are_policies_parsed_ = true;
00067 }
00068 
00069 CORBA::Policy *
00070 TAO_ZIOP_Stub::exposed_compression_id_list_policy (void)
00071 {
00072   if (!this->are_policies_parsed_)
00073     {
00074       this->parse_policies ();
00075     }
00076 
00077   return CORBA::Policy::_duplicate (this->compression_id_list_policy_.in ());
00078 }
00079 
00080 void
00081 TAO_ZIOP_Stub::exposed_compression_id_list_policy (CORBA::Policy_ptr policy)
00082 {
00083   this->compression_id_list_policy_ = CORBA::Policy::_duplicate (policy);
00084 }
00085 
00086 CORBA::Policy *
00087 TAO_ZIOP_Stub::exposed_compression_enabling_policy (void)
00088 {
00089   if (!this->are_policies_parsed_)
00090     {
00091       this->parse_policies ();
00092     }
00093 
00094   return CORBA::Policy::_duplicate (this->compression_enabling_policy_.in ());
00095 }
00096 
00097 void
00098 TAO_ZIOP_Stub::exposed_compression_enabling_policy (CORBA::Policy_ptr policy)
00099 {
00100   this->compression_enabling_policy_ = CORBA::Policy::_duplicate (policy);
00101 }
00102 
00103 CORBA::Policy_ptr
00104 TAO_ZIOP_Stub::get_policy (CORBA::PolicyType type)
00105 {
00106   // If we are dealing with a client exposed policy, check if any
00107   // value came in the IOR/reconcile IOR value and overrides.
00108   switch (type)
00109     {
00110       case ZIOP::COMPRESSION_ENABLING_POLICY_ID :
00111         {
00112           return this->effective_compression_enabling_policy ();
00113         }
00114       case ZIOP::COMPRESSOR_ID_LEVEL_LIST_POLICY_ID :
00115         {
00116           return this->effective_compression_id_list_policy ();
00117         }
00118     }
00119 
00120   return this->TAO_Stub::get_policy (type);
00121 }
00122 
00123 CORBA::Policy_ptr
00124 TAO_ZIOP_Stub::get_cached_policy (TAO_Cached_Policy_Type type)
00125 {
00126   // If we are dealing with a client exposed policy, check if any
00127   // value came in the IOR/reconcile IOR value and overrides.
00128   switch (type)
00129     {
00130       case TAO_CACHED_COMPRESSION_ENABLING_POLICY:
00131         {
00132           return this->effective_compression_enabling_policy ();
00133         }
00134       case TAO_CACHED_COMPRESSION_ID_LEVEL_LIST_POLICY:
00135         {
00136           return this->effective_compression_id_list_policy ();
00137         }
00138       default:
00139         break;
00140     }
00141 
00142   return this->TAO_Stub::get_cached_policy (type);
00143 }
00144 
00145 CORBA::Policy *
00146 TAO_ZIOP_Stub::effective_compression_enabling_policy (void)
00147 {
00148   // Get effective override.
00149   CORBA::Policy_var override =
00150     this->TAO_Stub::get_cached_policy (
00151       TAO_CACHED_COMPRESSION_ENABLING_POLICY);
00152 
00153   // Get the value from the ior.
00154   CORBA::Policy_var exposed = this->exposed_compression_enabling_policy ();
00155 
00156   // Reconcile client-exposed and locally set values.
00157   if (CORBA::is_nil (exposed.in ()))
00158     return override._retn ();
00159 
00160   if (CORBA::is_nil (override.in ()))
00161     return exposed._retn ();
00162 
00163   ZIOP::CompressionEnablingPolicy_var override_policy_var =
00164     ZIOP::CompressionEnablingPolicy::_narrow (override.in ());
00165 
00166   ZIOP::CompressionEnablingPolicy_var exposed_policy_var =
00167     ZIOP::CompressionEnablingPolicy::_narrow (exposed.in ());
00168 
00169   // Both override and exposed have been set.
00170   // See if either of them has empty priority bands.
00171   if (override_policy_var->compression_enabled () && exposed_policy_var->compression_enabled ())
00172     return override._retn ();
00173 
00174   if (!override_policy_var->compression_enabled ())
00175     return override._retn ();
00176 
00177   return exposed._retn ();
00178 }
00179 
00180 CORBA::Policy *
00181 TAO_ZIOP_Stub::effective_compression_id_list_policy (void)
00182 {
00183   // Get effective override.
00184   CORBA::Policy_var override =
00185     this->TAO_Stub::get_cached_policy (TAO_CACHED_COMPRESSION_ID_LEVEL_LIST_POLICY);
00186 
00187   // Get the value from the ior.
00188   CORBA::Policy_var exposed =
00189     this->exposed_compression_id_list_policy ();
00190 
00191   ZIOP::CompressorIdLevelListPolicy_var override_policy_var =
00192     ZIOP::CompressorIdLevelListPolicy::_narrow (override.in ());
00193 
00194   ZIOP::CompressorIdLevelListPolicy_var exposed_policy_var =
00195     ZIOP::CompressorIdLevelListPolicy::_narrow (exposed.in ());
00196 
00197     // Reconcile client-exposed and locally set values.
00198   if (CORBA::is_nil (exposed_policy_var.in ()))
00199     return override._retn ();
00200 
00201   if (CORBA::is_nil (override_policy_var.in ()))
00202     return exposed._retn ();
00203 
00204   // Check which compressor id we should use and which level
00205   for (CORBA::ULong nr_exposed = 0; 
00206         nr_exposed < exposed_policy_var->compressor_ids ()->length (); 
00207         ++nr_exposed)
00208     {
00209       ::Compression::CompressorIdLevel_var exposed_compressor = 
00210         exposed_policy_var->compressor_ids ()->operator [](nr_exposed);
00211 
00212       if (TAO_debug_level > 9)
00213         {
00214           ACE_DEBUG ((LM_DEBUG, 
00215                       ACE_TEXT ("TAO (%P|%t) - ")
00216                       ACE_TEXT ("TAO_ZIOP_Stub::effective_compression_id_list_policy, ")
00217                       ACE_TEXT ("exposed_policy = %d, compressor_id = %C, ")
00218                       ACE_TEXT ("compression_level = %d\n"), 
00219                       nr_exposed, 
00220                       TAO_ZIOP_Loader::ziop_compressorid_name (
00221                             exposed_compressor.ptr ()->compressor_id),
00222                       exposed_compressor.ptr ()->compression_level));
00223         }
00224       // check if a local policy matches this exposed policy
00225       for (CORBA::ULong nr_override = 0; 
00226             nr_override < override_policy_var->compressor_ids ()->length (); 
00227             ++nr_override)
00228         {
00229           ::Compression::CompressorIdLevel_var override_compressor = 
00230             override_policy_var->compressor_ids ()->operator [] (nr_override);
00231           if (TAO_debug_level > 9)
00232             {
00233               ACE_DEBUG ((LM_DEBUG, 
00234                           ACE_TEXT ("TAO (%P|%t) - ")
00235                           ACE_TEXT ("TAO_ZIOP_Stub::effective_compression_id_list_policy, ")
00236                           ACE_TEXT ("checking override_policy = %d, compressor_id = %C, ")
00237                           ACE_TEXT ("compression_level = %d\n"), 
00238                           nr_override, 
00239                           TAO_ZIOP_Loader::ziop_compressorid_name (
00240                                 override_compressor->compressor_id),
00241                           override_compressor->compression_level));
00242             }
00243           if (override_compressor->compressor_id == 
00244               exposed_compressor->compressor_id)
00245             {  
00246               CORBA::Policy_var tmp_policy = override_policy_var->copy ();
00247               ZIOP::CompressorIdLevelListPolicy_var idlevellist_policy_var =
00248                     ZIOP::CompressorIdLevelListPolicy::_narrow (tmp_policy.in ());
00249               if (CORBA::is_nil (idlevellist_policy_var.in ()))
00250                 return override._retn ();
00251 
00252               idlevellist_policy_var->compressor_ids ()->operator [] (0).compressor_id = 
00253                     override_compressor->compressor_id;
00254               //according to ZIOP spec, return the compressor with the lowest compression level.  
00255               idlevellist_policy_var.ptr ()->compressor_ids ()->operator [] (0).compression_level = 
00256                 ACE_MIN (override_compressor->compression_level,
00257                         exposed_compressor->compression_level);
00258 
00259               return idlevellist_policy_var._retn ();
00260             }
00261         }
00262     }
00263 
00264   return 0;
00265 }
00266 
00267 TAO_END_VERSIONED_NAMESPACE_DECL
00268 
00269 #endif