OrderedPtvSet.cpp

Go to the documentation of this file.
00001 // Copyright (C) 2006-2009 Kent-Andre Mardal and Simula Research Laboratory.
00002 // Licensed under the GNU GPL Version 2, or (at your option) any later version.
00003 
00004 #include "Ptv.h"
00005 #include "OrderedPtvSet.h"
00006 #include <vector>
00007 #include <stdexcept>
00008 #include <algorithm>
00009 
00010 namespace SyFi
00011 {
00012 
00013         // --- OrderedPtvSet
00014 
00015         OrderedPtvSet:: OrderedPtvSet()
00016         {
00017         }
00018 
00019         OrderedPtvSet::~OrderedPtvSet()
00020         {
00021                 Ptvs.clear();
00022         }
00023 
00024         OrderedPtvSet:: OrderedPtvSet(const Ptv& p0, const Ptv& p1)
00025         {
00026                 Ptvs.push_back(p0);
00027                 Ptvs.push_back(p1);
00028                 std::sort(Ptvs.begin(), Ptvs.end(), Ptv_is_less());
00029         }
00030 
00031         OrderedPtvSet:: OrderedPtvSet(const Ptv& p0, const Ptv& p1, const Ptv& p2)
00032         {
00033                 Ptvs.push_back(p0);
00034                 Ptvs.push_back(p1);
00035                 Ptvs.push_back(p2);
00036                 std::sort(Ptvs.begin(), Ptvs.end(), Ptv_is_less());
00037         }
00038 
00039         OrderedPtvSet:: OrderedPtvSet(const Ptv& p0, const Ptv& p1, const Ptv& p2, const Ptv& p3)
00040         {
00041                 Ptvs.push_back(p0);
00042                 Ptvs.push_back(p1);
00043                 Ptvs.push_back(p2);
00044                 Ptvs.push_back(p3);
00045                 std::sort(Ptvs.begin(), Ptvs.end(), Ptv_is_less());
00046         }
00047 
00048         void OrderedPtvSet:: append(const Ptv& p)
00049         {
00050                 Ptvs.push_back(p);
00051                 std::sort(Ptvs.begin(), Ptvs.end(), Ptv_is_less());
00052         }
00053 
00054         unsigned int OrderedPtvSet:: size() const
00055         {
00056                 return Ptvs.size();
00057         }
00058 
00059         const Ptv& OrderedPtvSet:: operator [] (unsigned int i) const
00060         {
00061                 return Ptvs[i];
00062         }
00063 
00064         Ptv& OrderedPtvSet:: operator [] (unsigned int i)
00065         {
00066                 return Ptvs[i];
00067         }
00068 
00069         OrderedPtvSet& OrderedPtvSet::operator = (const OrderedPtvSet& p)
00070         {
00071                 if ( this != &p)
00072                 {
00073                         Ptvs.clear();
00074                         for (unsigned int i=0; i<p.size(); i++)
00075                         {
00076                                 Ptvs.push_back(p[i]);
00077                         }
00078                 }
00079                 return *this;
00080         }
00081 
00082         bool OrderedPtvSet:: less(const OrderedPtvSet& p) const
00083         {
00084                 if ( Ptvs.size() <  p.size() ) return true ;
00085                 if ( Ptvs.size() > p.size() ) return false;
00086 
00087                 for (unsigned int i=Ptvs.size()-1; i>= 0; i--)
00088                 {
00089                         if ( Ptvs[i].less(p[i]) && p[i].less(Ptvs[i]))
00090                         {
00091                         }
00092                         else if ( Ptvs[i].less(p[i]) )
00093                         {
00094                                 return true;
00095                         }
00096                         else if ( p[i].less(Ptvs[i]) )
00097                         {
00098                                 return false;
00099                         }
00100                 }
00101                 return false;
00102         }
00103 
00104         std::ostream & operator<< ( std::ostream& os, const OrderedPtvSet& p)
00105         {
00106                 if (p.size() >= 1)
00107                 {
00108                         os <<"[";
00109                         for (unsigned int i=0; i< p.size()-1; i++)
00110                         {
00111                                 os <<p[i]<<",";
00112                         }
00113                         os <<p[p.size()-1]<<"]";
00114                 }
00115                 else
00116                 {
00117                         os <<"OrderedPtvSet not created properly"<<std::endl;
00118                 }
00119                 return os;
00120         }
00121 
00122         // --- OrderedPtvSet_i
00123 
00124         OrderedPtvSet_i :: OrderedPtvSet_i ()
00125         {
00126         }
00127 
00128         OrderedPtvSet_i::~OrderedPtvSet_i()
00129         {
00130         }
00131 
00132         OrderedPtvSet_i :: OrderedPtvSet_i (OrderedPtvSet& s, unsigned int i)
00133         {
00134                 si.first = s;
00135                 si.second.push_back(i);
00136         }
00137 
00138         OrderedPtvSet_i :: OrderedPtvSet_i (OrderedPtvSet& s, unsigned int i0, unsigned int i1)
00139         {
00140                 si.first = s;
00141                 si.second.push_back(i0);
00142                 si.second.push_back(i1);
00143         }
00144 
00145         const OrderedPtvSet&  OrderedPtvSet_i:: get_OrderedPtvSet() const
00146         {
00147                 return si.first;
00148         }
00149 
00150         unsigned int OrderedPtvSet_i:: get_i(unsigned int n) const
00151         {
00152                 if ( n >= 0 && n < si.second.size() )
00153                 {
00154                         return si.second[n];
00155                 }
00156                 else
00157                 {
00158 
00159                         throw(std::out_of_range("The index is out of range!"));
00160 
00161                 }
00162         }
00163 
00164         unsigned int OrderedPtvSet_i:: size() const
00165         {
00166                 return si.second.size();
00167         }
00168 
00169         bool OrderedPtvSet_i::less(const OrderedPtvSet_i& ss) const
00170         {
00171                 if ( si.second.size() < ss.size() ) return true;
00172                 if ( si.second.size() > ss.size() ) return false;
00173 
00174                 for (unsigned int d=0; d< si.second.size(); d++)
00175                 {
00176                         if ( si.second[d] < ss.get_i(d) ) return true;
00177                         if ( si.second[d] > ss.get_i(d) ) return false;
00178                 }
00179 
00180                 return si.first.less(ss.get_OrderedPtvSet());
00181 
00182         }
00183 
00184         std::ostream & operator<< ( std::ostream& os, const OrderedPtvSet_i& p)
00185         {
00186                 cout <<p.get_OrderedPtvSet();
00187                 if (p.size() >= 1)
00188                 {
00189                         os <<",[";
00190                         for (unsigned int i=0; i< p.size()-1; i++)
00191                         {
00192                                 os <<p.get_i(i)<<",";
00193                         }
00194                         os <<p.get_i(p.size()-1)<<"]";
00195                 }
00196                 else
00197                 {
00198                         os <<"OrderedPtvSet_i not created properly"<<std::endl;
00199                 }
00200                 return os;
00201         }
00202 
00203 }                                                                //namespace SyFi

Generated on Mon Aug 31 16:16:45 2009 for SyFi by  doxygen 1.5.9