TAO: ZIOP.cpp Source File

Go to the documentation of this file.
00001 #include "tao/ZIOP/ZIOP_ORBInitializer.h"
00002 #include "tao/ZIOP/ZIOP_Policy_Validator.h"
00003 #include "tao/ZIOP/ZIOP.h"
00004 #include "tao/ORB_Core.h"
00005 #include "tao/debug.h"
00006 #include "tao/ORBInitializer_Registry.h"
00007 #include "tao/operation_details.h"
00008 #include "tao/Stub.h"
00009 #include "tao/Transport.h"
00010 
00011 ACE_RCSID (ZIOP,
00012            ZIOP,
00013            "$Id: ZIOP.cpp 87890 2009-12-03 12:15:35Z johnnyw $")
00014 
00015 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00016 
00017 TAO_ZIOP_Loader::TAO_ZIOP_Loader (void)
00018   : initialized_ (false)
00019 {
00020 }
00021 
00022 TAO_ZIOP_Loader::~TAO_ZIOP_Loader (void)
00023 {
00024 }
00025 
00026 int
00027 TAO_ZIOP_Loader::init (int, ACE_TCHAR* [])
00028 {
00029 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
00030   if (!this->initialized_ && TAO_DEF_GIOP_MINOR >= 2)
00031     {
00032       PortableInterceptor::ORBInitializer_ptr tmp_orb_initializer =
00033         PortableInterceptor::ORBInitializer::_nil ();
00034       PortableInterceptor::ORBInitializer_var ziop_orb_initializer;
00035 
00036       try
00037         {
00038           /// Register the BiDir ORBInitializer.
00039           ACE_NEW_THROW_EX (tmp_orb_initializer,
00040                             TAO_ZIOP_ORBInitializer (this),
00041                             CORBA::NO_MEMORY (
00042                                 CORBA::SystemException::_tao_minor_code (
00043                                     TAO::VMCID,
00044                                     ENOMEM),
00045                                 CORBA::COMPLETED_NO));
00046 
00047           ziop_orb_initializer = tmp_orb_initializer;
00048 
00049           PortableInterceptor::register_orb_initializer (
00050             ziop_orb_initializer.in ());
00051 
00052           this->initialized_ = true;
00053         }
00054       catch (const ::CORBA::Exception& ex)
00055         {
00056           if (TAO_debug_level > 0)
00057             {
00058               ex._tao_print_exception ("Caught exception:");
00059             }
00060           return -1;
00061         }
00062     }
00063 #endif
00064   return 0;
00065 }
00066 
00067 void
00068 TAO_ZIOP_Loader::load_policy_validators (TAO_Policy_Validator &val)
00069 {
00070 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
00071   // Is this true? Does the GIOP protocol version matter here?
00072   if (TAO_DEF_GIOP_MINOR < 2)
00073     return;
00074 
00075   TAO_ZIOPPolicy_Validator *validator = 0;
00076   ACE_NEW_THROW_EX (validator,
00077                     TAO_ZIOPPolicy_Validator (val.orb_core ()),
00078                     CORBA::NO_MEMORY (
00079                         CORBA::SystemException::_tao_minor_code (
00080                             TAO::VMCID,
00081                             ENOMEM),
00082                         CORBA::COMPLETED_NO));
00083 
00084   // We may be adding another TAO_BiDirPolicy_Validator instance for
00085   // the same ORB (different POA). In cases where huge numbers of
00086   // bi-directional POA instances are created, having a validator
00087   // instance per POA may introduce additional delays in policy
00088   // validation and hence, the overal policy creation time. Since this
00089   // is out of the critical invocation processing path, I plan to keep
00090   // the design simple and not try to avoid an ineficiency of such
00091   // small proportions.
00092   val.add_validator (validator);
00093 #else
00094   ACE_UNUSED_ARG (val);
00095 #endif
00096 }
00097 
00098 int
00099 TAO_ZIOP_Loader::Initializer (void)
00100 {
00101   return ACE_Service_Config::process_directive (ace_svc_desc_TAO_ZIOP_Loader);
00102 }
00103 
00104 const char *
00105 TAO_ZIOP_Loader::ziop_compressorid_name (::Compression::CompressorId st)
00106 {
00107   switch (st)
00108     {
00109       case ::Compression::COMPRESSORID_NONE: return "NONE";
00110       case ::Compression::COMPRESSORID_GZIP: return "GZIP";
00111       case ::Compression::COMPRESSORID_PKZIP: return "PKZIP";
00112       case ::Compression::COMPRESSORID_BZIP2: return "BZIP2";
00113       case ::Compression::COMPRESSORID_ZLIB: return "ZLIB";
00114       case ::Compression::COMPRESSORID_LZMA: return "LZMA";
00115       case ::Compression::COMPRESSORID_LZO: return "LZO";
00116       case ::Compression::COMPRESSORID_RZIP: return "RZIP";
00117       case ::Compression::COMPRESSORID_7X: return "7X";
00118       case ::Compression::COMPRESSORID_XAR: return "XAR";
00119     }
00120   return "Unknown";
00121 }
00122 
00123 void
00124 TAO_ZIOP_Loader::dump_msg (const char *type,  const u_char *ptr,
00125                                 size_t len, size_t original_data_length,
00126                                 ::Compression::CompressorId  compressor_id,
00127                                 ::Compression::CompressionLevel compression_level)
00128 {
00129   if (TAO_debug_level < 10)
00130     {
00131       return;
00132     }
00133 
00134   static const char digits[] = "0123456789ABCD";
00135   int const byte_order = ptr[TAO_GIOP_MESSAGE_FLAGS_OFFSET] & 0x01;
00136   CORBA::Double const ratio = 100 - (((CORBA::Double)len/original_data_length) *
00137                                   (CORBA::Double) 100);
00138 
00139   ACE_DEBUG ((LM_DEBUG,
00140               ACE_TEXT ("TAO (%P|%t) - ZIOP_Loader::dump_msg, ")
00141               ACE_TEXT ("ZIOP message v%c.%c %C, %d data bytes, %s endian, ")
00142               ACE_TEXT ("original_data_length = %d, ratio = %4.2f, ")
00143               ACE_TEXT ("compressor = %C, compression_level = %d\n"),
00144               digits[ptr[TAO_GIOP_VERSION_MAJOR_OFFSET]],
00145               digits[ptr[TAO_GIOP_VERSION_MINOR_OFFSET]],
00146               type,
00147               len - TAO_GIOP_MESSAGE_HEADER_LEN ,
00148               (byte_order == TAO_ENCAP_BYTE_ORDER) ? ACE_TEXT("my") : ACE_TEXT("other"),
00149               original_data_length,
00150               ratio,
00151               TAO_ZIOP_Loader::ziop_compressorid_name(compressor_id),
00152               compression_level));
00153   ACE_HEX_DUMP ((LM_DEBUG,
00154                  (const char *) ptr,
00155                  len,
00156                  ACE_TEXT ("ZIOP message")));
00157 }
00158 
00159 bool
00160 TAO_ZIOP_Loader::decompress (Compression::Compressor_ptr compressor,
00161                              const ::Compression::Buffer &source,
00162                              ::Compression::Buffer &target)
00163 {
00164   try
00165     {
00166       compressor->decompress (source, target);
00167     }
00168   catch (::Compression::CompressionException &e)
00169     {
00170       ACE_ERROR_RETURN((LM_ERROR,
00171                         ACE_TEXT ("TAO (%P|%t) - TAO_ZIOP_Loader::decompress, ")
00172                         ACE_TEXT ("decompression failed, %C\n"),
00173                         e._info ().c_str ()),
00174                         false);
00175     }
00176 
00177   return true;
00178 }
00179 
00180 bool
00181 TAO_ZIOP_Loader::decompress (ACE_Data_Block **db, TAO_Queued_Data& qd,
00182                              TAO_ORB_Core& orb_core)
00183 {
00184 #if defined (TAO_HAS_ZIOP) && TAO_HAS_ZIOP == 0
00185   ACE_UNUSED_ARG (db);
00186   ACE_UNUSED_ARG (qd);
00187   ACE_UNUSED_ARG (orb_core);
00188   return true;
00189 #else
00190   CORBA::Object_var compression_manager =
00191     orb_core.resolve_compression_manager();
00192 
00193   Compression::CompressionManager_var manager =
00194     Compression::CompressionManager::_narrow (compression_manager.in ());
00195 
00196   if (!CORBA::is_nil(manager.in ()))
00197     {
00198       ZIOP::CompressionData data;
00199       // first set the read pointer after the header
00200       size_t begin = qd.msg_block ()-> rd_ptr() - qd.msg_block ()->base ();
00201       char * initial_rd_ptr = qd.msg_block ()-> rd_ptr();
00202       size_t const wr = qd.msg_block ()->wr_ptr () - qd.msg_block ()->base ();
00203 
00204       TAO_InputCDR cdr ((*db),
00205                         qd.msg_block ()->self_flags (),
00206                         begin + TAO_GIOP_MESSAGE_HEADER_LEN,
00207                         wr,
00208                         qd.byte_order (),
00209                         qd.giop_version ().major_version (),
00210                         qd.giop_version ().minor_version (),
00211                         &orb_core);
00212 
00213       if (!(cdr >> data))
00214         return false;
00215 
00216       Compression::Compressor_var compressor =
00217             manager->get_compressor (data.compressor, 6);
00218       CORBA::OctetSeq myout;
00219       myout.length (data.original_length);
00220 
00221       if (decompress(compressor.in(), data.data, myout))
00222         {
00223           size_t new_data_length = (size_t)(data.original_length +
00224                         TAO_GIOP_MESSAGE_HEADER_LEN);
00225 
00226           ACE_Message_Block mb (new_data_length);
00227           qd.msg_block ()->rd_ptr (initial_rd_ptr);
00228           mb.copy(qd.msg_block ()->base () + begin,
00229                         TAO_GIOP_MESSAGE_HEADER_LEN);
00230 
00231           if (mb.copy((char*)myout.get_buffer(false),
00232                   (size_t)data.original_length) != 0)
00233             ACE_ERROR_RETURN((LM_ERROR,
00234                               ACE_TEXT ("TAO - (%P|%t) - ")
00235                               ACE_TEXT ("TAO_ZIOP_Loader::decompress, ")
00236                               ACE_TEXT ("failed to copy decompressed data, ")
00237                               ACE_TEXT ("Buffer too small\n")),
00238                               false);
00239           // change it into a GIOP message..
00240           mb.base ()[0] = 0x47;
00241           ACE_CDR::mb_align (&mb);
00242 
00243           if (TAO_debug_level > 9)
00244             {  // we're only logging ZIOP messages. Log datablock before it's
00245                // replaced by it's decompressed datablock
00246                this->dump_msg ("before decompression",
00247                     reinterpret_cast <u_char *>(qd.msg_block ()->rd_ptr ()),
00248                     qd.msg_block ()->length (), data.original_length,
00249                     data.compressor, compressor->compression_level ());
00250             }
00251           //replace data block
00252           *db = mb.data_block ()->duplicate ();
00253           (*db)->size (new_data_length);
00254           return true;
00255         }
00256     }
00257   else
00258     {
00259       return false;
00260     }
00261 
00262   return true;
00263 #endif
00264 }
00265 
00266 CORBA::ULong
00267 TAO_ZIOP_Loader::compression_policy_value (CORBA::Policy_ptr policy) const
00268 {
00269   CORBA::ULong result = 0;
00270 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
00271 
00272   if (!CORBA::is_nil (policy))
00273     {
00274       ZIOP::CompressionLowValuePolicy_var srp =
00275         ZIOP::CompressionLowValuePolicy::_narrow (policy);
00276 
00277       if (!CORBA::is_nil (srp.in ()))
00278         {
00279           result = srp->low_value ();
00280         }
00281     }
00282 #else
00283   ACE_UNUSED_ARG (policy);
00284 #endif
00285   return result;
00286 }
00287 
00288 bool
00289 TAO_ZIOP_Loader::compress (Compression::Compressor_ptr compressor,
00290                            const ::Compression::Buffer &source,
00291                            ::Compression::Buffer &target)
00292 {
00293   try
00294     {
00295       compressor->compress (source, target);
00296     }
00297   catch (::Compression::CompressionException &e)
00298     {
00299       ACE_ERROR_RETURN((LM_ERROR,
00300                         ACE_TEXT ("TAO (%P|%t) - TAO_ZIOP_Loader::compress, ")
00301                         ACE_TEXT ("compression failed, %C\n"),
00302                         e._info ().c_str ()),
00303                         false);
00304     }
00305 
00306   return true;
00307 }
00308 
00309 ::Compression::CompressionRatio
00310 TAO_ZIOP_Loader::get_ratio (CORBA::OctetSeq& uncompressed, CORBA::OctetSeq& compressed)
00311 {
00312   return (::Compression::CompressionRatio)uncompressed.length () / compressed.length ();
00313 }
00314 
00315 bool
00316 TAO_ZIOP_Loader::check_min_ratio (const ::Compression::CompressionRatio& this_ratio,
00317                                   ::Compression::CompressionRatio overall_ratio,
00318                                   ::Compression::CompressionRatio min_ratio) const
00319 {
00320   bool accepted = min_ratio == 0 || (this_ratio * 10000) > (min_ratio * 10000);
00321   if (TAO_debug_level > 8)
00322     {
00323       ACE_ERROR ((LM_ERROR,
00324                   ACE_TEXT ("TAO (%P|%t) - TAO_ZIOP_Loader::check_min_ratio, ")
00325                   ACE_TEXT ("overall_ratio = %d, this_ratio = %d, accepted = %d\n"),
00326                   overall_ratio, this_ratio, accepted));
00327     }
00328   return accepted;
00329 }
00330 
00331 
00332 bool
00333 TAO_ZIOP_Loader::get_compressor_details (
00334                         ::Compression::CompressorIdLevelList *list,
00335                         Compression::CompressorId &compressor_id,
00336                         Compression::CompressionLevel &compression_level)
00337 
00338 {
00339   if (list)
00340     {
00341       compressor_id = (*list)[0].compressor_id;
00342       compression_level = (*list)[0].compression_level;
00343 
00344       if (TAO_debug_level > 6)
00345         {
00346           ACE_DEBUG ((LM_DEBUG,
00347                       ACE_TEXT ("TAO (%P|%t) - ")
00348                       ACE_TEXT ("TAO_ZIOP_Loader::get_compressor_details,")
00349                       ACE_TEXT ("compressor policy found, compressor = %C, ")
00350                       ACE_TEXT ("compression_level = %d\n"),
00351                       TAO_ZIOP_Loader::ziop_compressorid_name (compressor_id),
00352                           compression_level));
00353         }
00354 
00355     }
00356   else
00357     {
00358       if (TAO_debug_level > 6)
00359         {
00360           ACE_DEBUG ((LM_DEBUG,
00361                       ACE_TEXT ("TAO (%P|%t) - ")
00362                       ACE_TEXT ("TAO_ZIOP_Loader::get_compressor_details, ")
00363                       ACE_TEXT ("no appropriate compressor found\n")));
00364         }
00365       return false;
00366     }
00367   return true;
00368 }
00369 
00370 bool
00371 TAO_ZIOP_Loader::get_compression_details(
00372                         CORBA::Policy_ptr compression_enabling_policy,
00373                         CORBA::Policy_ptr compression_level_list_policy,
00374                         Compression::CompressorId &compressor_id,
00375                         Compression::CompressionLevel &compression_level)
00376 {
00377   bool use_ziop = false;
00378   if (!CORBA::is_nil (compression_enabling_policy))
00379     {
00380       ZIOP::CompressionEnablingPolicy_var srp =
00381         ZIOP::CompressionEnablingPolicy::_narrow (compression_enabling_policy);
00382 
00383       if (!CORBA::is_nil (srp.in ()))
00384         {
00385           use_ziop = srp->compression_enabled ();
00386           if (!use_ziop && TAO_debug_level > 8)
00387             {
00388               ACE_DEBUG ((LM_DEBUG,
00389                           ACE_TEXT ("TAO (%P|%t) - ")
00390                           ACE_TEXT ("TAO_ZIOP_Loader::get_compression_details, ")
00391                           ACE_TEXT ("ZIOP enabled policy not set\n")));
00392             }
00393         }
00394     }
00395   else
00396     {
00397       if (TAO_debug_level > 6)
00398         {
00399           ACE_ERROR((LM_ERROR,
00400                      ACE_TEXT ("TAO (%P|%t) - ")
00401                      ACE_TEXT ("TAO_ZIOP_Loader::get_compression_details, ")
00402                      ACE_TEXT ("compression_enabling_policy is NIL, no ZIOP\n")));
00403         }
00404     }
00405 
00406   if (use_ziop)
00407     {
00408       if (!CORBA::is_nil (compression_level_list_policy))
00409         {
00410           ZIOP::CompressorIdLevelListPolicy_var srp =
00411             ZIOP::CompressorIdLevelListPolicy::_narrow (compression_level_list_policy);
00412 
00413           if (!CORBA::is_nil (srp.in ()))
00414             {
00415               use_ziop = get_compressor_details (srp->compressor_ids (),
00416                                     compressor_id, compression_level);
00417             }
00418         }
00419       else
00420         {
00421           if (TAO_debug_level > 6)
00422             {
00423               ACE_ERROR((LM_ERROR,
00424                          ACE_TEXT("TAO (%P|%t) - ")
00425                          ACE_TEXT("TAO_ZIOP_Loader::get_compression_details, ")
00426                          ACE_TEXT("compressor ID/Level list policy not found\n")));
00427             }
00428           use_ziop = false;
00429         }
00430     }
00431   return use_ziop;
00432 }
00433 
00434 bool
00435 TAO_ZIOP_Loader::complete_compression (Compression::Compressor_ptr compressor,
00436                                        TAO_OutputCDR &cdr,
00437                                        ACE_Message_Block& mb,
00438                                        char *initial_rd_ptr,
00439                                        CORBA::ULong low_value,
00440                                        Compression::CompressionRatio min_ratio,
00441                                        CORBA::ULong original_data_length,
00442                                        Compression::CompressorId compressor_id)
00443 {
00444   if (low_value > 0 && original_data_length > low_value)
00445     {
00446       CORBA::OctetSeq output;
00447       CORBA::OctetSeq input (original_data_length, &mb);
00448       output.length (original_data_length);
00449 
00450       if (!this->compress (compressor, input, output))
00451         return false;
00452       else if ((output.length () < original_data_length) &&
00453               (this->check_min_ratio (this->get_ratio (input, output),
00454                       compressor->compression_ratio(),
00455                       min_ratio)))
00456         {
00457           mb.wr_ptr (mb.rd_ptr ());
00458           cdr.current_alignment (mb.wr_ptr() - mb.base ());
00459           ZIOP::CompressionData data;
00460           data.compressor = compressor_id;
00461           data.original_length = input.length();
00462           data.data = output;
00463           cdr << data;
00464           mb.rd_ptr(initial_rd_ptr);
00465           int begin = (mb.rd_ptr() - mb.base ());
00466           mb.data_block ()->base ()[0 + begin] = 0x5A;
00467           mb.data_block ()->base ()[TAO_GIOP_MESSAGE_SIZE_OFFSET + begin] =
00468             cdr.length() - TAO_GIOP_MESSAGE_HEADER_LEN;
00469 
00470           if (TAO_debug_level > 9)
00471             {
00472                this->dump_msg ("after compression", reinterpret_cast <u_char *>(mb.rd_ptr ()),
00473                     mb.length (), data.original_length,
00474                     data.compressor, compressor->compression_level ());
00475             }
00476 
00477         }
00478       else
00479         return false;
00480     }
00481     else if (TAO_debug_level > 8)
00482       {
00483         ACE_DEBUG ((LM_DEBUG,
00484                     ACE_TEXT ("TAO (%P|%t) - ")
00485                     ACE_TEXT ("TAO_ZIOP_Loader::compress_data, ")
00486                     ACE_TEXT ("no compression used, ")
00487                     ACE_TEXT ("low value policy applied\n")));
00488       }
00489   return true;
00490 }
00491 
00492 bool
00493 TAO_ZIOP_Loader::compress_data (TAO_OutputCDR &cdr,
00494                CORBA::Object_ptr compression_manager,
00495                CORBA::ULong low_value,
00496                ::Compression::CompressionRatio min_ratio,
00497                ::Compression::CompressorId compressor_id,
00498                ::Compression::CompressionLevel compression_level)
00499 {
00500   bool compressed = true;
00501 
00502   cdr.consolidate ();
00503 
00504   ACE_Message_Block* current = const_cast <ACE_Message_Block*> (cdr.current ());
00505 
00506   char* initial_rd_ptr = current->rd_ptr();
00507 
00508   // Set the read pointer to the point where the data starts
00509   current->rd_ptr (TAO_GIOP_MESSAGE_HEADER_LEN);
00510 
00511   current = const_cast <ACE_Message_Block*> (cdr.current());
00512   CORBA::ULong const original_data_length =
00513     (CORBA::ULong)(current->wr_ptr() - current->rd_ptr());
00514 
00515   if (original_data_length > 0)
00516     {
00517       Compression::CompressionManager_var manager =
00518         Compression::CompressionManager::_narrow (compression_manager);
00519 
00520       if (!CORBA::is_nil(manager.in ()))
00521         {
00522           Compression::Compressor_var compressor =
00523             manager->get_compressor (compressor_id, compression_level);
00524 
00525           compressed = complete_compression(compressor.in (), cdr, *current,
00526                 initial_rd_ptr, low_value, min_ratio,
00527                 original_data_length, compressor_id);
00528         }
00529     }
00530   // set back read pointer in case no compression was done...
00531   current->rd_ptr(initial_rd_ptr);
00532   return compressed;
00533 }
00534 
00535 bool
00536 TAO_ZIOP_Loader::marshal_data (TAO_OutputCDR &cdr, TAO_Stub& stub)
00537 {
00538 #if defined (TAO_HAS_ZIOP) && TAO_HAS_ZIOP == 0
00539   ACE_UNUSED_ARG (cdr);
00540   ACE_UNUSED_ARG (stub);
00541   return true;
00542 #else
00543   CORBA::Boolean use_ziop = false;
00544 
00545   Compression::CompressorId compressor_id = Compression::COMPRESSORID_NONE;
00546   Compression::CompressionLevel compression_level = 0;
00547 
00548   CORBA::Policy_var compression_enabling_policy =
00549     stub.get_cached_policy (TAO_CACHED_COMPRESSION_ENABLING_POLICY);
00550   CORBA::Policy_var compression_level_list_policy =
00551     stub.get_cached_policy (TAO_CACHED_COMPRESSION_ID_LEVEL_LIST_POLICY);
00552 
00553   use_ziop = get_compression_details(compression_enabling_policy.in (),
00554                       compression_level_list_policy.in (),
00555                       compressor_id, compression_level);
00556 
00557   if (use_ziop)
00558     {
00559       CORBA::Object_var compression_manager =
00560         stub.orb_core ()->resolve_compression_manager();
00561 
00562       CORBA::Policy_var policy_low_value =
00563         stub.get_cached_policy (TAO_CACHED_COMPRESSION_LOW_VALUE_POLICY);
00564       CORBA::Policy_var policy_min_ratio =
00565         stub.get_cached_policy (TAO_CACHED_MIN_COMPRESSION_RATIO_POLICY);
00566 
00567       CORBA::ULong low_value =
00568         this->compression_policy_value (policy_low_value.in ());
00569       Compression::CompressionRatio min_ratio =
00570         this->compression_policy_value (policy_min_ratio.in ());
00571 
00572       return compress_data(cdr, compression_manager.in (),
00573                             low_value, min_ratio,
00574                             compressor_id, compression_level);
00575     }
00576   return false;
00577 #endif
00578 }
00579 
00580 bool
00581 TAO_ZIOP_Loader::marshal_data (TAO_OutputCDR& cdr, TAO_ORB_Core& orb_core)
00582 {
00583 #if defined (TAO_HAS_ZIOP) && TAO_HAS_ZIOP == 0
00584   ACE_UNUSED_ARG (cdr);
00585   ACE_UNUSED_ARG (orb_core);
00586   return true;
00587 #else
00588   CORBA::Boolean use_ziop = false;
00589   Compression::CompressorId compressor_id = Compression::COMPRESSORID_NONE;
00590   Compression::CompressionLevel compression_level = 0;
00591 
00592   CORBA::Policy_var compression_enabling_policy =
00593     orb_core.get_cached_policy_including_current
00594       (TAO_CACHED_COMPRESSION_ENABLING_POLICY);
00595 
00596   CORBA::Policy_var compression_level_list_policy =
00597     orb_core.get_cached_policy_including_current
00598       (TAO_CACHED_COMPRESSION_ID_LEVEL_LIST_POLICY);
00599 
00600   use_ziop = get_compression_details(compression_enabling_policy.in (),
00601                       compression_level_list_policy.in (),
00602                       compressor_id, compression_level);
00603 
00604   if (use_ziop)
00605     {
00606       CORBA::Object_var compression_manager =
00607         orb_core.resolve_compression_manager();
00608 
00609       CORBA::Policy_var policy_low_value =
00610         orb_core.get_cached_policy_including_current
00611           (TAO_CACHED_COMPRESSION_LOW_VALUE_POLICY);
00612 
00613       CORBA::Policy_var policy_min_ratio =
00614         orb_core.get_cached_policy_including_current
00615           (TAO_CACHED_MIN_COMPRESSION_RATIO_POLICY);
00616 
00617       CORBA::ULong low_value =
00618         this->compression_policy_value (policy_low_value.in ());
00619       Compression::CompressionRatio min_ratio =
00620         this->compression_policy_value (policy_min_ratio.in ());
00621 
00622       return compress_data(cdr, compression_manager.in (),
00623                            low_value, min_ratio,
00624                            compressor_id, compression_level);
00625     }
00626   return false;
00627 
00628 #endif
00629 }
00630 
00631 
00632 ACE_STATIC_SVC_DEFINE (TAO_ZIOP_Loader,
00633                        ACE_TEXT ("ZIOP_Loader"),
00634                        ACE_SVC_OBJ_T,
00635                        &ACE_SVC_NAME (TAO_ZIOP_Loader),
00636                        ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ,
00637                        0)
00638 
00639 ACE_FACTORY_DEFINE (TAO_ZIOP, TAO_ZIOP_Loader)
00640 
00641 TAO_END_VERSIONED_NAMESPACE_DECL