vtf-logo

FixedArray0.h

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 
00008 #if !defined(__FixedArray0_h__)
00009 #error This file is an implementation detail of the class FixedArray.
00010 #endif
00011 
00012 #include "../defs.h"
00013 
00014 BEGIN_NAMESPACE_ADS
00015 
00017 template <typename T>
00018 class FixedArray<0,T> {
00019   //
00020   // Private types.
00021   //
00022 
00023 private:
00024 
00025   typedef ArrayTypes<T> Types;
00026 
00027   //
00028   // Public types.
00029   //
00030 
00031 public:
00032 
00033   //--------------------------------------------------------------------------
00035   // @{
00036 
00038   typedef typename Types::value_type value_type;
00040   typedef typename Types::parameter_type parameter_type;
00042   typedef typename Types::pointer pointer;
00044   typedef typename Types::const_pointer const_pointer;
00046   typedef typename Types::iterator iterator;
00048   typedef typename Types::const_iterator const_iterator;
00050   typedef typename Types::reference reference;
00052   typedef typename Types::const_reference const_reference;
00054 
00060   typedef typename Types::size_type size_type;
00062   typedef typename Types::difference_type difference_type;
00063 
00065 
00066 public:
00067 
00068   //--------------------------------------------------------------------------
00070   // @{
00071 
00073   FixedArray()
00074   {}
00075 
00077   ~FixedArray() 
00078   {}
00079 
00081   FixedArray(const FixedArray& x)
00082   {}
00083 
00085   template <typename T2> 
00086   FixedArray(const FixedArray<0,T2>& x)
00087   {}
00088 
00090   explicit 
00091   FixedArray(parameter_type x)
00092   {}
00093 
00095   FixedArray(const void* vp)
00096   {}
00097 
00098   // @}
00099   //--------------------------------------------------------------------------
00101   // @{
00102 
00104   FixedArray& 
00105   operator=(const FixedArray& x) {
00106     return *this;
00107   }
00108 
00110   FixedArray& 
00111   operator=(parameter_type x) {
00112     return *this;
00113   }
00114 
00116   template <typename T2> 
00117   FixedArray& 
00118   operator=(const FixedArray<0,T2>& x) {
00119     return *this;
00120   }
00121 
00123   template<typename T2, bool A>
00124   FixedArray& 
00125   operator=(const Array<1, T2, A>& x) {
00126 #ifdef DEBUG_FixedArray
00127     assert(size() == x.size());
00128 #endif
00129     return *this;
00130   }
00131 
00132   // @}
00133   //--------------------------------------------------------------------------
00135   // @{
00136 
00138   static
00139   size_type
00140   size() { 
00141     return 0;
00142   }
00143 
00145   static
00146   bool
00147   empty() { 
00148     return true;
00149   }
00150 
00152   static
00153   size_type
00154   max_size() { 
00155     return std::numeric_limits<int>::max() / sizeof(value_type); 
00156   }
00157 
00158   // @}
00159   //--------------------------------------------------------------------------
00161   // @{
00162 
00164   const_iterator 
00165   begin() const { 
00166     return 0; 
00167   }
00168 
00170   const_iterator 
00171   end() const { 
00172     return 0;
00173   }
00174 
00176   const_pointer 
00177   data() const { 
00178     return 0;
00179   }
00180 
00182   template <typename EqualityComparable>
00183   bool
00184   has(const EqualityComparable& x) const {
00185     return false;
00186   }
00187 
00189   bool
00190   is_sorted() const {
00191     return true;
00192   }
00193 
00195   template <class StrictWeakOrdering>
00196   bool
00197   is_sorted(StrictWeakOrdering comp) const {
00198     return true;
00199   }
00200 
00201   // @}
00202   //--------------------------------------------------------------------------
00204   // @{
00205 
00207   iterator 
00208   begin() { 
00209     return 0; 
00210   }
00211 
00213   iterator 
00214   end() { 
00215     return 0;
00216   }
00217 
00219   pointer 
00220   data() { 
00221     return 0; 
00222   }
00223 
00225   void
00226   swap(FixedArray& x)
00227   {}
00228 
00230   void
00231   negate()
00232   {}
00233 
00235   void
00236   fill(parameter_type value)
00237   {}
00238 
00240   template <typename InputIterator>
00241   void
00242   copy(InputIterator start, InputIterator finish) {
00243 #ifdef DEBUG_FixedArray
00244     assert(start == finish);
00245 #endif
00246   }
00247     
00249   void
00250   sort()
00251   {}
00252 
00254   template <class StrictWeakOrdering>
00255   void
00256   sort(StrictWeakOrdering comp)
00257   {}
00258 
00259   // @}
00260   //--------------------------------------------------------------------------
00262   // @{
00263 
00265   FixedArray& 
00266   operator+=(parameter_type x) {
00267     return *this;
00268   }
00269 
00271   FixedArray& 
00272   operator-=(parameter_type x) {
00273     return *this;
00274   }
00275 
00277   FixedArray& 
00278   operator*=(parameter_type x) {
00279     return *this;
00280   }
00281 
00283   FixedArray& 
00284   operator/=(parameter_type x) {
00285     return *this;
00286   }
00287 
00289   FixedArray& 
00290   operator%=(parameter_type x) {
00291     return *this;
00292   }
00293 
00295   FixedArray& 
00296   operator<<=(const int offset) {
00297     return *this;
00298   }
00299 
00301   FixedArray& 
00302   operator>>=(const int offset) {
00303     return *this;
00304   }
00305 
00306   // @}
00307   //--------------------------------------------------------------------------
00309   // @{
00310 
00312   template<typename T2>
00313   FixedArray& 
00314   operator+=(const FixedArray<0,T2>& x) {
00315     return *this;
00316   }
00317 
00319   template<typename T2>
00320   FixedArray& 
00321   operator-=(const FixedArray<0,T2>& x) {
00322     return *this;
00323   }
00324 
00326   template<typename T2>
00327   FixedArray& 
00328   operator*=(const FixedArray<0,T2>& x) {
00329     return *this;
00330   }
00331 
00333   template<typename T2>
00334   FixedArray& 
00335   operator/=(const FixedArray<0,T2>& x) {
00336 #ifdef DEBUG_FixedArray
00337     assert(x[0] != 0);
00338 #endif
00339     return *this;
00340   }
00341 
00343   template<typename T2>
00344   FixedArray& 
00345   operator%=(const FixedArray<0,T2>& x) {
00346 #ifdef DEBUG_FixedArray
00347     assert(x[0] != 0);
00348 #endif
00349     return *this;
00350   }
00351 
00352   // @}
00353   //--------------------------------------------------------------------------
00355   // @{
00356 
00358   void
00359   abs()
00360   {}
00361 
00363   void
00364   acos()
00365   {}
00366 
00368   void
00369   asin()
00370   {}
00371 
00373   void
00374   atan()
00375   {}
00376 
00378   void
00379   ceil()
00380   {}
00381 
00383   void
00384   cos()
00385   {}
00386 
00388   void
00389   cosh()
00390   {}
00391 
00393   void
00394   exp()
00395   {}
00396 
00398   void
00399   floor()
00400   {}
00401 
00403   void
00404   log()
00405   {}
00406 
00408   void
00409   log10()
00410   {}
00411 
00413   void
00414   sin()
00415   {}
00416 
00418   void
00419   sinh()
00420   {}
00421 
00423   void
00424   sqrt()
00425   {}
00426 
00428   void
00429   tan()
00430   {}
00431 
00433   void
00434   tanh()
00435   {}
00436 
00437   // @}
00438 };
00439 
00440 END_NAMESPACE_ADS
00441 
00442 #define __FixedArray0_ipp__
00443 #include "FixedArray0.ipp"
00444 #undef __FixedArray0_ipp__

Generated on Fri Aug 24 12:55:24 2007 for Algorithms and Data Structures Package by  doxygen 1.4.7