TAO_CosTime: TAO_TIO.cpp Source File

00001 // TAO_TIO.cpp,v 1.20 2006/03/14 06:14:35 jtc Exp
00002 
00003 #include "orbsvcs/Time/TAO_TIO.h"
00004 
00005 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00006 
00007 // Constructor.
00008 TAO_TIO::TAO_TIO (TimeBase::TimeT lower,
00009                   TimeBase::TimeT upper)
00010 {
00011   this->attr_time_interval.lower_bound = lower;
00012   this->attr_time_interval.upper_bound = upper;
00013 }
00014 
00015 // Destructor.
00016 TAO_TIO::~TAO_TIO (void)
00017 {
00018 }
00019 
00020 // This is the get method for the attribute time interval.
00021 
00022 TimeBase::IntervalT
00023 TAO_TIO::time_interval (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
00024     ACE_THROW_SPEC ((CORBA::SystemException))
00025 {
00026   return attr_time_interval;
00027 }
00028 
00029 // This operation returns a value of type OverlapType depending on how
00030 // the interval in the object and the time range represented by the
00031 // parameter UTO overlap.  If OverlapType is not OTNoOverlap, then the
00032 // out parameter overlap contains the overlap interval, otherwise the
00033 // out parameter contains the gap between the two intervals.
00034 
00035 CosTime::OverlapType
00036 TAO_TIO::spans (CosTime::UTO_ptr uto,
00037                 CosTime::TIO_out overlap
00038                 ACE_ENV_ARG_DECL)
00039     ACE_THROW_SPEC ((CORBA::SystemException))
00040 {
00041   TAO_TIO *tio = 0;
00042 
00043   ACE_TRY
00044     {
00045       TimeBase::TimeT lb1 =
00046         this->time_interval ().lower_bound;
00047 
00048       TimeBase::TimeT up1 =
00049         this->time_interval ().upper_bound;
00050 
00051       TimeBase::TimeT tmp1 = uto->time (ACE_ENV_SINGLE_ARG_PARAMETER);
00052       ACE_TRY_CHECK;
00053 
00054       TimeBase::TimeT tmp2 = uto->inaccuracy (ACE_ENV_SINGLE_ARG_PARAMETER);
00055       ACE_TRY_CHECK;
00056 
00057       TimeBase::TimeT lb2 = tmp1 - tmp2;
00058 
00059 
00060       tmp1 = uto->time (ACE_ENV_SINGLE_ARG_PARAMETER);
00061       ACE_TRY_CHECK;
00062 
00063       tmp2 = uto->inaccuracy (ACE_ENV_SINGLE_ARG_PARAMETER);
00064       ACE_TRY_CHECK;
00065 
00066       TimeBase::TimeT up2 = tmp1 + tmp2;
00067 
00068       if (lb1 == lb2 && up1 == up2)
00069         {
00070           ACE_NEW_RETURN (tio,
00071                           TAO_TIO (lb1, up1),
00072                           CosTime::OTNoOverlap);
00073           overlap = tio->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00074           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00075 
00076           return CosTime::OTOverlap;
00077         }
00078       else if (lb1 > lb2 && up1 < up2)
00079         {
00080           ACE_NEW_RETURN (tio,
00081                           TAO_TIO (lb1, up1),
00082                           CosTime::OTNoOverlap);
00083 
00084           overlap = tio->_this ();
00085           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00086 
00087           return CosTime::OTContained;
00088         }
00089       else if (lb1 < lb2 && up1 > up2)
00090         {
00091           ACE_NEW_RETURN (tio,
00092                           TAO_TIO (lb2, up2),
00093                           CosTime::OTNoOverlap);
00094 
00095           overlap = tio->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00096           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00097 
00098           return CosTime::OTContained;
00099         }
00100       else if (lb1 < lb2)
00101         {
00102           if (up1 < lb2)
00103             {
00104               ACE_NEW_RETURN (tio,
00105                               TAO_TIO (0, 0),
00106                               CosTime::OTNoOverlap);
00107 
00108               overlap = tio->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00109               ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00110 
00111               return CosTime::OTNoOverlap;
00112             }
00113           else
00114             {
00115               ACE_NEW_RETURN (tio,
00116                               TAO_TIO (lb2, up1),
00117                               CosTime::OTNoOverlap);
00118               overlap = tio->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00119               ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00120 
00121               return CosTime::OTOverlap;
00122             }
00123         }
00124       else if (up2 < lb1)
00125         {
00126 
00127           ACE_NEW_RETURN (tio,
00128                           TAO_TIO (0, 0),
00129                           CosTime::OTNoOverlap);
00130 
00131           overlap = tio->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00132           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00133 
00134           return CosTime::OTNoOverlap;
00135         }
00136       else
00137         {
00138           ACE_NEW_RETURN (tio,
00139                           TAO_TIO (lb1, up2),
00140                           CosTime::OTNoOverlap);
00141 
00142           overlap = tio->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00143           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00144         }
00145     }
00146   ACE_CATCHANY
00147     {
00148       ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception:");
00149     }
00150   ACE_ENDTRY;
00151   ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00152 
00153   return CosTime::OTNoOverlap;
00154 }
00155 
00156 // This operation returns a value of type OverlapType depending on how
00157 // the interval in the object and interval in the parameter TIO
00158 // overlap. If OverlapType is not OTNoOverlap, then the out parameter
00159 // overlap contains the overlap interval, otherwise the out parameter
00160 // contains the gap between the two intervals.
00161 
00162 CosTime::OverlapType
00163 TAO_TIO::overlaps (CosTime::TIO_ptr tio,
00164                    CosTime::TIO_out overlap
00165                    ACE_ENV_ARG_DECL)
00166     ACE_THROW_SPEC ((CORBA::SystemException))
00167 {
00168   TAO_TIO *tio_i = 0;
00169 
00170   TimeBase::TimeT lb1 =
00171     this->time_interval ().lower_bound;
00172 
00173   TimeBase::TimeT up1 =
00174     this->time_interval ().upper_bound;
00175 
00176   TimeBase::TimeT lb2 =
00177     tio->time_interval ().lower_bound;
00178 
00179   TimeBase::TimeT up2 =
00180     tio->time_interval ().upper_bound;
00181 
00182   if (lb1 == lb2 && up1 == up2)
00183     {
00184       ACE_NEW_THROW_EX (tio_i,
00185                         TAO_TIO (lb1, up1),
00186                         CORBA::NO_MEMORY ());
00187 
00188       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00189 
00190       overlap = tio_i->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00191       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00192 
00193       return CosTime::OTOverlap;
00194     }
00195   else if (lb1 > lb2 && up1 < up2)
00196     {
00197       ACE_NEW_THROW_EX (tio_i,
00198                         TAO_TIO (lb1, up1),
00199                         CORBA::NO_MEMORY ());
00200       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00201 
00202       overlap = tio_i->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00203       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00204 
00205       return CosTime::OTContained;
00206     }
00207   else if (lb1 < lb2 && up1 > up2)
00208     {
00209       ACE_NEW_THROW_EX (tio_i,
00210                         TAO_TIO (lb2, up2),
00211                         CORBA::NO_MEMORY ());
00212       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00213 
00214       overlap = tio_i->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00215       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00216 
00217       return CosTime::OTContained;
00218     }
00219   else if (lb1 < lb2)
00220     {
00221       if (up1 < lb2)
00222         {
00223           ACE_NEW_THROW_EX (tio_i,
00224                             TAO_TIO (0, 0),
00225                             CORBA::NO_MEMORY ());
00226           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00227           overlap = tio_i->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00228           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00229 
00230           return CosTime::OTNoOverlap;
00231         }
00232       else
00233         {
00234           ACE_NEW_THROW_EX (tio_i,
00235                             TAO_TIO (lb2, up1),
00236                             CORBA::NO_MEMORY ());
00237           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00238 
00239           overlap = tio_i->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00240           ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00241 
00242           return CosTime::OTOverlap;
00243         }
00244     }
00245   else if (up2 < lb1)
00246     {
00247       ACE_NEW_THROW_EX (tio_i,
00248                         TAO_TIO (0, 0),
00249                         CORBA::NO_MEMORY ());
00250       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00251 
00252       overlap = tio_i->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00253       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00254 
00255       return CosTime::OTNoOverlap;
00256     }
00257   else
00258     {
00259       ACE_NEW_THROW_EX (tio_i,
00260                         TAO_TIO (lb1, up2),
00261                         CORBA::NO_MEMORY ());
00262       ACE_CHECK_RETURN (CosTime::OTNoOverlap);
00263       overlap = tio_i->_this ();
00264     }
00265 
00266   return CosTime::OTNoOverlap;
00267 }
00268 
00269 CosTime::UTO_ptr
00270 TAO_TIO::time (ACE_ENV_SINGLE_ARG_DECL)
00271     ACE_THROW_SPEC ((CORBA::SystemException))
00272 {
00273   TAO_UTO *uto = 0;
00274 
00275   ACE_NEW_THROW_EX (uto,
00276                     TAO_UTO ((this->time_interval ().upper_bound -
00277                               this->time_interval ().lower_bound) / 2,
00278                              this->time_interval ().upper_bound -
00279                              this->time_interval ().lower_bound,
00280                              0),
00281                     CORBA::NO_MEMORY ());
00282 
00283   ACE_CHECK_RETURN (CosTime::UTO::_nil ());
00284 
00285   return uto->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
00286 }
00287 
00288 TAO_END_VERSIONED_NAMESPACE_DECL