E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeBaseSTInstance.h

Go to the documentation of this file.

/************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright  2001-2007 INPE and Tecgraf/PUC-Rio.

This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

You should have received a copy of the GNU Lesser General Public
License along with this library.

The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
#ifndef  __TERRALIB_INTERNAL_BASESTINSTANCE_H
#define  __TERRALIB_INTERNAL_BASESTINSTANCE_H

#include "TeCoord2D.h"
#include "TeGeometryAlgorithms.h"
#include "TeAttribute.h"
#include "TeSharedPtr.h"

#include <string>
#include <map> 
#include <vector>

using namespace std;

class TeTheme;

template<typename GeometryType, typename TimeType>
class TeBaseSTInstance
{
           
protected:
           string                                                 object_id_;                      
           vector<string>                              unique_id_;           
           vector<string>                              properties_;          
           GeometryType                                geometries_;          
           TimeType                                    time_;                
           int                                                               slice_;               
           TeSharedPtr<TeAttributeList>     attrList_;                       
                      
public:               

           TeBaseSTInstance() : object_id_(""), slice_(-1), attrList_(0)
           { }

           TeBaseSTInstance (const string& object_id, const vector<string>& prop, TeAttributeList* attList = 0, const int& s = -1) : 
                      object_id_(object_id), 
                      properties_(prop),
                      slice_(s),
                      attrList_(TeSharedPtr<TeAttributeList>(attList))
                      { } 

           TeBaseSTInstance (const string& object_id, const GeometryType& geometries, const TimeType& time, 
                      const int& s = -1) : 
                      object_id_(object_id), 
                      geometries_(geometries),
                      time_(time),
                      slice_(s),
                      attrList_(0)
                      { } 

           TeBaseSTInstance (const string& object_id, const vector<string>& prop, TeAttributeList* attList,
                      const GeometryType& geometries,  const int& slice, const TimeType& time ) :
                      object_id_(object_id), 
                      properties_(prop),
                      geometries_(geometries),
                      time_(time),
                      slice_(slice),
                      attrList_(TeSharedPtr<TeAttributeList>(attList))
                      { } 
                                 
           virtual ~TeBaseSTInstance() 
           { } 

           virtual bool operator== (const TeBaseSTInstance<GeometryType, TimeType>& other);

           virtual string getObjectId () 
           {          return object_id_;    }
           
           virtual void setObjectId (const string& id) 
           {          object_id_ = id;      }

           virtual string objectId () 
           {          return getObjectId(); }
           
           virtual void objectId (const string& id) 
           {          setObjectId(id);      }

           virtual vector<string>& getUniqueId() 
           {          return unique_id_;    }

           virtual string getUniqueId(const int& i); 
           
           virtual void setUniqueId (const vector<string>& id) 
           {          unique_id_ = id;      }

           virtual void addUniqueId (const string& id) 
           {          unique_id_.push_back(id);        }

           virtual vector<string>& uniqueId () 
           {          return getUniqueId(); }

           virtual string uniqueId (int index) 
           {          return getUniqueId(index);       }
           
           virtual void uniqueId (const vector<string>& ids) 
           {          setUniqueId(ids);     }

           virtual TimeType getTime() 
           {          return time_;         }
           
           virtual void setTime (const TimeType& t) 
           {          time_ = t; }

           virtual void setProperties(const vector<string>& p) 
           {          properties_ = p;      }

           virtual void setProperties(TePropertyVector& p); 

           virtual bool setPropertyValue (const int& i, const string& val); 

           virtual bool setPropertyValue (const string& name, const string& val); 

           virtual void addPropertyValue (const string& val)
           {          properties_.push_back (val); }

           virtual bool removePropertyValue (const int& i); 


           virtual bool addProperty(TeProperty& prop); 

           virtual bool addProperty(TeAttribute& rep); 
           
           virtual vector<string>& getProperties()
           {          return properties_;   }

           virtual void getPropertyVector(TePropertyVector& propVec); 

           TePropertyVector getPropertyVector(); 
           
           virtual bool getProperty (TeProperty& prop, unsigned int i = 0);  
           
           virtual bool getProperty (TeProperty& prop, string name); 
           
           virtual bool getPropertyValue (string& val, const int& i = 0); 

           virtual bool getPropertyValue (const string& name, string& val); 
           
           virtual double operator[](int i); 

           virtual void properties(TePropertyVector& p)
           {          setProperties(p); }

           virtual GeometryType& getGeometries() 
           {          return geometries_;}

           virtual void setGeometry(const GeometryType& g)
           {          geometries_ = g; }

           virtual GeometryType& geometries() 
           {          return getGeometries();}

           virtual void setSlice (int s) 
           {          slice_ = s; }

           virtual int getSlice()
           {          return slice_; }

           virtual void slice (int s) 
           {          setSlice(s); }

           virtual int slice()
           {          return getSlice(); }

           const TeAttributeList*           getAttrList()
           {          return attrList_.nakedPointer(); }

           void setAttrList(const TeAttributeList& attList); 

           void setAttrList(TeSharedPtr<TeAttributeList>& attrList);

           virtual void clear();

           virtual TeCoord2D getCentroid();

           virtual double getArea();

           virtual bool isTimeValid()
           {          return false; } 
           
           virtual TeTheme* theme() 
           { return 0; }

           virtual void theme(TeTheme*)  
           {  }
};

template<typename GeometryType, typename TimeType> bool
TeBaseSTInstance<GeometryType, TimeType>::operator== (const TeBaseSTInstance<GeometryType, TimeType>& other)
{
           return ( (object_id_ == other.object_id_) && 
                                  (time_ == other.time_) &&
                                  (slice_ == other.slice_));
}

template<typename GeometryType, typename TimeType> string 
TeBaseSTInstance<GeometryType, TimeType>::getUniqueId(const int& i) 
{          
           if(i<(int)unique_id_.size())
                      return unique_id_[i]; 
           return "";
}

template<typename GeometryType, typename TimeType> void 
TeBaseSTInstance<GeometryType, TimeType>::setAttrList(const TeAttributeList& attList)
{
           attrList_.reset(new TeAttributeList()); 
           *attrList_ = attList;
}

template<typename GeometryType, typename TimeType> void 
TeBaseSTInstance<GeometryType, TimeType>::setAttrList(TeSharedPtr<TeAttributeList>& attList)
{
           attrList_ = attList;
}

template<typename GeometryType, typename TimeType> void 
TeBaseSTInstance<GeometryType, TimeType>::setProperties(TePropertyVector& p)
{
           properties_.clear();
           TePropertyVector::iterator it = p.begin();
           while(it!=p.end())
           {
                      addPropertyValue(it->value_); 
                      ++it;
           }
}

template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::setPropertyValue (const int& i, const string& val)
{          
           if(i<0 || i>=(int)properties_.size())
                      return false;
           properties_[i] = val;
           return true;
}

template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::setPropertyValue (const string& name, const string& val)
{          
           if(!attrList_.isActive())
                      return false;

           string newName = TeConvertToUpperCase(name); 
           size_t pos = name.find(".", 0, 1);
           if (pos != string::npos)
                      newName = TeConvertToUpperCase((name.substr(pos+1)));

           for(unsigned int i=0; i<attrList_->size(); ++i)
           {
                      string s = TeConvertToUpperCase((attrList_->operator[](i)).rep_.name_);
                      if( (s == TeConvertToUpperCase(name)) || (s == newName))
                      {
                                 if(i>=properties_.size())
                                            return false;
                                 properties_[i] = val;
                                 return true;
                      }
           }
           return false; 
}

template<typename GeometryType, typename TimeType> void  
TeBaseSTInstance<GeometryType, TimeType>::getPropertyVector(TePropertyVector& propVec)
{
           if(!attrList_.isActive())
                      return;
    if(properties_.size()!=attrList_->size())
                      return;
           propVec.clear();
           for(unsigned int i=0; i<properties_.size(); ++i)
           {
                      TeProperty p;
                      p.value_ = properties_[i];
                      p.attr_ = attrList_->operator[](i);
                      propVec.push_back(p);
           }
}

template<typename GeometryType, typename TimeType> TePropertyVector  
TeBaseSTInstance<GeometryType, TimeType>::getPropertyVector()
{
           TePropertyVector vec; 
           this->getPropertyVector(vec);
           return vec;
}

template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::getProperty (TeProperty& prop, unsigned int i)
{
           if(!attrList_.isActive())
                      return false;

           if(i>=properties_.size() || i>=attrList_->size())
                      return false;
           prop.value_ = properties_[i];
           prop.attr_ = (*attrList_)[i];
           return true;
}

template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::getProperty (TeProperty& prop, string name)
{
           if(!attrList_.isActive())
                      return false;
            if(properties_.size()!=attrList_->size())
                      return false;

           string newName = TeConvertToUpperCase(name); 
           size_t pos = name.find(".", 0, 1);
           if (pos != string::npos)
                      newName = TeConvertToUpperCase(name.substr(pos+1));

           for(unsigned int i=0; i<attrList_->size(); ++i)
           {
                      string s = TeConvertToUpperCase((attrList_->operator[](i)).rep_.name_); 
                      if((s == TeConvertToUpperCase(name)) || (s == newName))
                      {
                                 prop.value_ = properties_[i];
                                 prop.attr_ = attrList_->operator[](i);
                                 return true;
                      }
           }
           return false; 
}
           
template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::getPropertyValue (string& val, const int& i)
{
           if(i<0 || i>= (int)properties_.size())
                      return false;
           val = properties_[i];
           return true;
}

template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::getPropertyValue (const string& name, string& val)
{          
           if(!attrList_.isActive())
                      return false;

           if(properties_.size()!=attrList_->size())
                      return false;

           string newName = TeConvertToUpperCase(name); 
           size_t pos = name.find(".", 0, 1);
           if (pos != string::npos)
                      newName = TeConvertToUpperCase(name.substr(pos+1));

           for(unsigned int i=0; i<attrList_->size(); ++i)
           {
                      string s = TeConvertToUpperCase((attrList_->operator[](i)).rep_.name_); 
                      if((s == TeConvertToUpperCase(name)) || (s == newName))
                      {
                                 val = properties_[i];
                                 return true;
                      }
           }
           return false; 
}

template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::addProperty(TeProperty& prop)
{
           if(!attrList_.isActive())
                      return false;

           string newName = TeConvertToUpperCase(prop.attr_.rep_.name_); 
           size_t pos = (prop.attr_.rep_.name_).find(".", 0, 1);
           if (pos != string::npos)
                      newName = TeConvertToUpperCase(prop.attr_.rep_.name_.substr(pos+1));

           for(unsigned int i=0; i<attrList_->size(); ++i)
           {
                      string s = TeConvertToUpperCase((attrList_->operator[](i)).rep_.name_); 
                      if((s == TeConvertToUpperCase(prop.attr_.rep_.name_)) || (s == newName))
                      {
                                 //the property already exists
                                 if(i>=properties_.size())
                                            properties_.push_back (prop.value_);
                                 else
                                            properties_[i] = prop.value_;
                                 return true;
                      }
           }

           // Adds a new property
           attrList_->push_back(prop.attr_);
           properties_.push_back (prop.value_);
           return true; 
}

template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::addProperty(TeAttribute& attr)
{
           if(!attrList_.isActive())
                      return false;
           attrList_->push_back(attr);
           return true; 
}

template<typename GeometryType, typename TimeType> bool 
TeBaseSTInstance<GeometryType, TimeType>::removePropertyValue(const int& i)
{
           int index = 0;
           vector<string>::iterator it = properties_.begin();
           while(it!=properties_.end())
           {
                      if(index==i)
                      {
                                 properties_.erase(it);
                                 return true;
                      }
                      ++it;
                      ++index;
           }
           return false;
}

template<typename GeometryType, typename TimeType> double 
TeBaseSTInstance<GeometryType, TimeType>::operator[](int i)
{          
           double val = TeMAXFLOAT; 
           if(i<0 || i>=(int)properties_.size() || properties_[i].empty())
                      return val;
           val = atof(properties_[i].c_str()); 
           return val;  
}
           
template<typename GeometryType, typename TimeType> void
TeBaseSTInstance<GeometryType, TimeType>::clear()
{
           object_id_ = ""; 
           slice_ = -1; 
    properties_.clear(); 
           unique_id_.clear();
           attrList_.reset(0);
}


template<typename GeometryType, typename TimeType> TeCoord2D
TeBaseSTInstance<GeometryType, TimeType>::getCentroid()
{
           return TeFindCentroid(this->getGeometries());
}

template<typename GeometryType, typename TimeType> double
TeBaseSTInstance<GeometryType, TimeType>::getArea()
{
           return TeGeometryArea(this->getGeometries());
}

                                 
#endif