Back to index

nordugrid-arc-nox  1.1.0~rc6
DBranch.cpp
Go to the documentation of this file.
00001 // -*- indent-tabs-mode: nil -*-
00002 
00003 #include "DBranch.h"
00004 
00005 namespace Arc {
00006 
00007   DBranch::DBranch(void)
00008     : item_(new DItem) {}
00009 
00010   DBranch::~DBranch(void) {
00011     delete item_;
00012   }
00013 
00014   DBranch& DBranch::operator[](const std::string& name) {
00015     for (std::list<DBranch*>::iterator b = branches_.begin(); b != branches_.end(); ++b)
00016       if ((*b)->name_ == name)
00017         return **b;
00018     return **(branches_.insert(branches_.end(), new DBranch));
00019   }
00020 
00021   DBranch& DBranch::operator[](int pos) {
00022     std::list<DBranch*>::iterator b = branches_.begin();
00023     for (; b != branches_.end(); ++b) {
00024       if (pos <= 0)
00025         break;
00026       --pos;
00027     }
00028     if (b != branches_.end())
00029       return **b;
00030     return **(branches_.insert(b, new DBranch));
00031   }
00032 
00033   DBranch& DBranch::Add(const std::string&, int pos) {
00034     std::list<DBranch*>::iterator b = branches_.begin();
00035     for (; b != branches_.end(); ++b) {
00036       if (pos <= 0)
00037         break;
00038       --pos;
00039     }
00040     return **(branches_.insert(b, new DBranch));
00041   }
00042 
00043   int DBranch::Size(void) {
00044     return branches_.size();
00045   }
00046 
00047   const std::string& DBranch::Name(void) {
00048     return name_;
00049   }
00050 
00051   DItem& DBranch::Item(void) {
00052     return *item_;
00053   }
00054 
00055   DBranch::operator DItem&(void) {
00056     return *item_;
00057   }
00058 
00059   DBranch& DBranch::operator=(const DItem& item) {
00060     DItem *old_item = item_;
00061     DItem *new_item = item.New();
00062     if (new_item) {
00063       item_ = new_item;
00064       if (old_item)
00065         delete old_item;
00066     }
00067     return *this;
00068   }
00069 
00070   void DBranch::Assign(DItem *item) {
00071     DItem *old_item = item_;
00072     if (!item)
00073       item_ = new DItem;
00074     else
00075       item_ = item;
00076     if (old_item)
00077       delete old_item;
00078   }
00079 
00080   DItemString::DItemString(const std::string& s)
00081     : value_(s) {}
00082 
00083   DItemString::DItemString(const char *s)
00084     : value_(s) {}
00085 
00086   DItem* DItemString::New(void) const {
00087     return new DItemString(value_);
00088   }
00089 
00090   DItemString::~DItemString(void) {}
00091 
00092   std::string DItemString::str() const {
00093     return value_;
00094   }
00095 
00096   bool DItemString::operator==(const DItem& item) {
00097     const DItemString *sitem = dynamic_cast<const DItemString*>(&item);
00098     if (sitem)
00099       return (value_ == sitem->value_);
00100     return (value_ == item.str());
00101   }
00102 
00103   bool DItemString::operator<(const DItem& item) {
00104     const DItemString *sitem = dynamic_cast<const DItemString*>(&item);
00105     if (sitem)
00106       return (value_ < sitem->value_);
00107     return (value_ < item.str());
00108   }
00109 
00110   bool DItemString::operator>(const DItem& item) {
00111     const DItemString *sitem = dynamic_cast<const DItemString*>(&item);
00112     if (sitem)
00113       return (value_ < sitem->value_);
00114     return (value_ < item.str());
00115   }
00116 
00117   bool DItemString::operator<=(const DItem& item) {
00118     const DItemString *sitem = dynamic_cast<const DItemString*>(&item);
00119     if (sitem)
00120       return (value_ <= sitem->value_);
00121     return (value_ <= item.str());
00122   }
00123 
00124   bool DItemString::operator>=(const DItem& item) {
00125     const DItemString *sitem = dynamic_cast<const DItemString*>(&item);
00126     if (sitem)
00127       return (value_ >= sitem->value_);
00128     return (value_ >= item.str());
00129   }
00130 
00131   DItemString::operator bool(void) {
00132     return !value_.empty();
00133   }
00134 
00135   bool DItemString::operator!(void) {
00136     return value_.empty();
00137   }
00138 
00139   DItemString& DItemString::operator=(const DItem& item) {
00140     const DItemString *sitem = dynamic_cast<const DItemString*>(&item);
00141     if (sitem)
00142       value_ = sitem->value_;
00143     else
00144       value_ = item.str();
00145     return *this;
00146   }
00147 
00148   DItemString& DItemString::operator=(const std::string& s) {
00149     value_ = s;
00150     return *this;
00151   }
00152 
00153 
00154 }