sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

+ backports cosmetics

Browse source 
+ backports avoid static string as datasource name
This commit is contained in:
Lucio Asnaghi 2010-11-16 21:20:40 +00:00
parent 980098e2d5
commit b4421bc39c
3 changed files with 201 additions and 200 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

327
plugins/input/shape/shape.cpp
View file

@ -47,23 +47,23 @@ using mapnik::filter_at_point;
using mapnik::attribute_descriptor; using mapnik::attribute_descriptor;
shape_datasource::shape_datasource(const parameters &params, bool bind) shape_datasource::shape_datasource(const parameters &params, bool bind)
: datasource (params), : datasource (params),
type_(datasource::Vector), type_(datasource::Vector),
file_length_(0), file_length_(0),
indexed_(false), indexed_(false),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8")) desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8"))
{ {
boost::optional<std::string> file = params.get<std::string>("file"); boost::optional<std::string> file = params.get<std::string>("file");
if (!file) throw datasource_exception("missing <file> parameter"); if (!file) throw datasource_exception("missing <file> parameter");
boost::optional<std::string> base = params.get<std::string>("base"); boost::optional<std::string> base = params.get<std::string>("base");
if (base) if (base)
shape_name_ = *base + "/" + *file; shape_name_ = *base + "/" + *file;
else else
shape_name_ = *file; shape_name_ = *file;
boost::algorithm::ireplace_last(shape_name_,".shp","");
boost::algorithm::ireplace_last(shape_name_,".shp","");
if (bind) if (bind)
{ {
this->bind(); this->bind();
@ -73,204 +73,207 @@ shape_datasource::shape_datasource(const parameters &params, bool bind)
void shape_datasource::bind() const void shape_datasource::bind() const
{ {
if (is_bound_) return; if (is_bound_) return;
if (!boost::filesystem::exists(shape_name_ + ".shp"))
{
throw datasource_exception(shape_name_ + " does not exist");
}
try if (!boost::filesystem::exists(shape_name_ + ".shp"))
{ {
shape_io shape(shape_name_); throw datasource_exception("shapefile '" + shape_name_ + ".shp' does not exist");
// leave ABI alone }
((shape_datasource*)this)->init(shape);
for (int i=0;i<shape.dbf().num_fields();++i) if (boost::filesystem::is_directory(shape_name_ + ".shp"))
{ {
field_descriptor const& fd=shape.dbf().descriptor(i); throw datasource_exception("shapefile '" + shape_name_ + ".shp' appears to be a directory not a file");
std::string fld_name=fd.name_; }
switch (fd.type_)
{ try
{
shape_io shape(shape_name_);
// leave ABI alone
((shape_datasource*)this)->init(shape);
for (int i=0;i<shape.dbf().num_fields();++i)
{
field_descriptor const& fd=shape.dbf().descriptor(i);
std::string fld_name=fd.name_;
switch (fd.type_)
{
case 'C': case 'C':
case 'D': case 'D':
case 'M': case 'M':
case 'L': case 'L':
desc_.add_descriptor(attribute_descriptor(fld_name, String)); desc_.add_descriptor(attribute_descriptor(fld_name, String));
break; break;
case 'N': case 'N':
case 'F': case 'F':
{ {
if (fd.dec_>0) if (fd.dec_>0)
{ {
desc_.add_descriptor(attribute_descriptor(fld_name,Double,false,8)); desc_.add_descriptor(attribute_descriptor(fld_name,Double,false,8));
} }
else else
{ {
desc_.add_descriptor(attribute_descriptor(fld_name,Integer,false,4)); desc_.add_descriptor(attribute_descriptor(fld_name,Integer,false,4));
} }
break; break;
} }
default: default:
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
std::clog << "unknown type "<<fd.type_<<"\n"; std::clog << "unknown type "<<fd.type_<<"\n";
#endif #endif
break; break;
} }
} }
} }
catch (datasource_exception& ex) catch (datasource_exception& ex)
{ {
std::clog<<ex.what()<<std::endl; std::clog<<ex.what()<<std::endl;
throw; throw;
} }
catch (...) catch (...)
{ {
std::clog << " got exception ... \n"; std::clog << " got exception ... \n";
throw; throw;
} }
is_bound_ = true; is_bound_ = true;
} }
shape_datasource::~shape_datasource() {} shape_datasource::~shape_datasource() {}
const std::string shape_datasource::name_="shape";
void shape_datasource::init(shape_io& shape) void shape_datasource::init(shape_io& shape)
{ {
//first read header from *.shp //first read header from *.shp
int file_code=shape.shp().read_xdr_integer(); int file_code=shape.shp().read_xdr_integer();
if (file_code!=9994) if (file_code!=9994)
{ {
//invalid file code //invalid file code
throw datasource_exception((boost::format("wrong file code : %d") % file_code).str()); throw datasource_exception((boost::format("wrong file code : %d") % file_code).str());
} }
shape.shp().skip(5*4); shape.shp().skip(5*4);
file_length_=shape.shp().read_xdr_integer(); file_length_=shape.shp().read_xdr_integer();
int version=shape.shp().read_ndr_integer(); int version=shape.shp().read_ndr_integer();
if (version!=1000) if (version!=1000)
{ {
//invalid version number //invalid version number
throw datasource_exception((boost::format("invalid version number: %d") % version).str()); throw datasource_exception((boost::format("invalid version number: %d") % version).str());
} }
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
int shape_type = shape.shp().read_ndr_integer(); int shape_type = shape.shp().read_ndr_integer();
#else #else
shape.shp().skip(4); shape.shp().skip(4);
#endif #endif
shape.shp().read_envelope(extent_);
shape.shp().read_envelope(extent_);
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
double zmin = shape.shp().read_double(); double zmin = shape.shp().read_double();
double zmax = shape.shp().read_double(); double zmax = shape.shp().read_double();
double mmin = shape.shp().read_double(); double mmin = shape.shp().read_double();
double mmax = shape.shp().read_double(); double mmax = shape.shp().read_double();
std::clog << "Z min/max " << zmin << "," << zmax << "\n"; std::clog << "Z min/max " << zmin << "," << zmax << "\n";
std::clog << "M min/max " << mmin << "," << mmax << "\n"; std::clog << "M min/max " << mmin << "," << mmax << "\n";
#else #else
shape.shp().skip(4*8); shape.shp().skip(4*8);
#endif #endif
// check if we have an index file around // check if we have an index file around
std::string index_name(shape_name_+".index"); std::string index_name(shape_name_+".index");
std::ifstream file(index_name.c_str(),std::ios::in | std::ios::binary); std::ifstream file(index_name.c_str(),std::ios::in | std::ios::binary);
if (file) if (file)
{ {
indexed_=true; indexed_=true;
file.close(); file.close();
} }
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
std::clog << extent_ << std::endl; std::clog << extent_ << std::endl;
std::clog << "file_length=" << file_length_ << std::endl; std::clog << "file_length=" << file_length_ << std::endl;
std::clog << "shape_type=" << shape_type << std::endl; std::clog << "shape_type=" << shape_type << std::endl;
#endif #endif
}
std::string shape_datasource::name()
{
return "shape";
} }
int shape_datasource::type() const int shape_datasource::type() const
{ {
return type_; return type_;
} }
layer_descriptor shape_datasource::get_descriptor() const layer_descriptor shape_datasource::get_descriptor() const
{ {
if (!is_bound_) bind(); if (!is_bound_) bind();
return desc_; return desc_;
}
std::string shape_datasource::name()
{
return name_;
} }
featureset_ptr shape_datasource::features(const query& q) const featureset_ptr shape_datasource::features(const query& q) const
{ {
if (!is_bound_) bind(); if (!is_bound_) bind();
filter_in_box filter(q.get_bbox()); filter_in_box filter(q.get_bbox());
if (indexed_)
{ if (indexed_)
return featureset_ptr {
(new shape_index_featureset<filter_in_box>(filter, return featureset_ptr
shape_name_, (new shape_index_featureset<filter_in_box>(filter,
q.property_names(), shape_name_,
desc_.get_encoding())); q.property_names(),
} desc_.get_encoding()));
else }
{ else
return featureset_ptr {
(new shape_featureset<filter_in_box>(filter, return featureset_ptr
shape_name_, (new shape_featureset<filter_in_box>(filter,
q.property_names(), shape_name_,
desc_.get_encoding(), q.property_names(),
file_length_)); desc_.get_encoding(),
} file_length_));
}
} }
featureset_ptr shape_datasource::features_at_point(coord2d const& pt) const featureset_ptr shape_datasource::features_at_point(coord2d const& pt) const
{ {
if (!is_bound_) bind(); if (!is_bound_) bind();
filter_at_point filter(pt); filter_at_point filter(pt);
// collect all attribute names
std::vector<attribute_descriptor> const& desc_vector = desc_.get_descriptors(); // collect all attribute names
std::vector<attribute_descriptor>::const_iterator itr = desc_vector.begin(); std::vector<attribute_descriptor> const& desc_vector = desc_.get_descriptors();
std::vector<attribute_descriptor>::const_iterator end = desc_vector.end(); std::vector<attribute_descriptor>::const_iterator itr = desc_vector.begin();
std::set<std::string> names; std::vector<attribute_descriptor>::const_iterator end = desc_vector.end();
std::set<std::string> names;
while (itr != end)
{ while (itr != end)
names.insert(itr->get_name()); {
++itr; names.insert(itr->get_name());
} ++itr;
}
if (indexed_)
{ if (indexed_)
return featureset_ptr {
(new shape_index_featureset<filter_at_point>(filter, return featureset_ptr
shape_name_, (new shape_index_featureset<filter_at_point>(filter,
names, shape_name_,
desc_.get_encoding())); names,
} desc_.get_encoding()));
else }
{ else
return featureset_ptr {
(new shape_featureset<filter_at_point>(filter, return featureset_ptr
shape_name_, (new shape_featureset<filter_at_point>(filter,
names, shape_name_,
desc_.get_encoding(), names,
file_length_)); desc_.get_encoding(),
} file_length_));
}
} }
Envelope<double> shape_datasource::envelope() const Envelope<double> shape_datasource::envelope() const
{ {
if (!is_bound_) bind(); if (!is_bound_) bind();
return extent_; return extent_;
} }

7
plugins/input/shape/shape.hpp
View file

@ -42,14 +42,14 @@ class shape_datasource : public datasource
public: public:
shape_datasource(const parameters &params, bool bind=true); shape_datasource(const parameters &params, bool bind=true);
virtual ~shape_datasource(); virtual ~shape_datasource();
int type() const; int type() const;
static std::string name(); static std::string name();
featureset_ptr features(const query& q) const; featureset_ptr features(const query& q) const;
featureset_ptr features_at_point(coord2d const& pt) const; featureset_ptr features_at_point(coord2d const& pt) const;
Envelope<double> envelope() const; Envelope<double> envelope() const;
layer_descriptor get_descriptor() const; layer_descriptor get_descriptor() const;
void bind() const; void bind() const;
private: private:
shape_datasource(const shape_datasource&); shape_datasource(const shape_datasource&);
shape_datasource& operator=(const shape_datasource&); shape_datasource& operator=(const shape_datasource&);
@ -61,7 +61,6 @@ class shape_datasource : public datasource
mutable Envelope<double> extent_; mutable Envelope<double> extent_;
mutable bool indexed_; mutable bool indexed_;
mutable layer_descriptor desc_; mutable layer_descriptor desc_;
static const std::string name_;
}; };
#endif //SHAPE_HPP #endif //SHAPE_HPP

67
plugins/input/shape/shapefile.hpp
View file

@ -51,7 +51,7 @@ struct RecordTag
{ {
return static_cast<data_type>(::operator new(sizeof(char)*size)); return static_cast<data_type>(::operator new(sizeof(char)*size));
} }
static void dealloc(data_type data) static void dealloc(data_type data)
{ {
::operator delete(data); ::operator delete(data);
@ -72,89 +72,89 @@ struct shape_record
size_t size; size_t size;
mutable size_t pos; mutable size_t pos;
explicit shape_record(size_t size) explicit shape_record(size_t size)
: :
data(Tag::alloc(size)), data(Tag::alloc(size)),
size(size), size(size),
pos(0) {} pos(0) {}
void set_data(typename Tag::data_type data_) void set_data(typename Tag::data_type data_)
{ {
data = data_; data = data_;
} }
typename Tag::data_type get_data() typename Tag::data_type get_data()
{ {
return data; return data;
} }
void skip(unsigned n) void skip(unsigned n)
{ {
pos+=n; pos+=n;
} }
int read_ndr_integer() int read_ndr_integer()
{ {
boost::int32_t val; boost::int32_t val;
read_int32_ndr(&data[pos],val); read_int32_ndr(&data[pos],val);
pos+=4; pos+=4;
return val; return val;
} }
int read_xdr_integer() int read_xdr_integer()
{ {
boost::int32_t val; boost::int32_t val;
read_int32_xdr(&data[pos],val); read_int32_xdr(&data[pos],val);
pos+=4; pos+=4;
return val; return val;
} }
double read_double() double read_double()
{ {
double val; double val;
read_double_ndr(&data[pos],val); read_double_ndr(&data[pos],val);
pos+=8; pos+=8;
return val; return val;
} }
long remains()
long remains()
{ {
return (size-pos); return (size-pos);
} }
~shape_record() ~shape_record()
{ {
Tag::dealloc(data); Tag::dealloc(data);
} }
}; };
using namespace boost::iostreams; using namespace boost::iostreams;
class shape_file : boost::noncopyable class shape_file : boost::noncopyable
{ {
#ifdef SHAPE_MEMORY_MAPPED_FILE #ifdef SHAPE_MEMORY_MAPPED_FILE
stream<mapped_file_source> file_; stream<mapped_file_source> file_;
#else #else
stream<file_source> file_; stream<file_source> file_;
#endif #endif
public: public:
#ifdef SHAPE_MEMORY_MAPPED_FILE #ifdef SHAPE_MEMORY_MAPPED_FILE
typedef shape_record<MappedRecordTag> record_type; typedef shape_record<MappedRecordTag> record_type;
#else #else
typedef shape_record<RecordTag> record_type; typedef shape_record<RecordTag> record_type;
#endif #endif
shape_file() {} shape_file() {}
shape_file(std::string const& file_name) shape_file(std::string const& file_name)
: :
#ifdef SHAPE_MEMORY_MAPPED_FILE #ifdef SHAPE_MEMORY_MAPPED_FILE
file_(file_name) file_(file_name)
#else #else
file_(file_name,std::ios::in | std::ios::binary) file_(file_name,std::ios::in | std::ios::binary)
#endif #endif
{} {}
~shape_file() {} ~shape_file() {}
inline bool is_open() inline bool is_open()
@ -162,13 +162,12 @@ public:
return file_.is_open(); return file_.is_open();
} }
inline void close() inline void close()
{ {
if (file_ && file_.is_open()) if (file_ && file_.is_open())
file_.close(); file_.close();
} }
inline void read_record(record_type& rec) inline void read_record(record_type& rec)
{ {
#ifdef SHAPE_MEMORY_MAPPED_FILE #ifdef SHAPE_MEMORY_MAPPED_FILE
@ -178,7 +177,7 @@ public:
file_.read(rec.get_data(),rec.size); file_.read(rec.get_data(),rec.size);
#endif #endif
} }
inline int read_xdr_integer() inline int read_xdr_integer()
{ {
char b[4]; char b[4];
@ -187,7 +186,7 @@ public:
read_int32_xdr(b,val); read_int32_xdr(b,val);
return val; return val;
} }
inline int read_ndr_integer() inline int read_ndr_integer()
{ {
char b[4]; char b[4];
@ -196,7 +195,7 @@ public:
read_int32_ndr(b,val); read_int32_ndr(b,val);
return val; return val;
} }
inline double read_double() inline double read_double()
{ {
double val; double val;
@ -209,7 +208,7 @@ public:
#endif #endif
return val; return val;
} }
inline void read_envelope(Envelope<double>& envelope) inline void read_envelope(Envelope<double>& envelope)
{ {
#ifndef MAPNIK_BIG_ENDIAN #ifndef MAPNIK_BIG_ENDIAN
@ -223,29 +222,29 @@ public:
read_double_ndr(data + 2*8,maxx); read_double_ndr(data + 2*8,maxx);
read_double_ndr(data + 3*8,maxy); read_double_ndr(data + 3*8,maxy);
envelope.init(minx,miny,maxx,maxy); envelope.init(minx,miny,maxx,maxy);
#endif #endif
} }
inline void skip(std::streampos bytes) inline void skip(std::streampos bytes)
{ {
file_.seekg(bytes,std::ios::cur); file_.seekg(bytes,std::ios::cur);
} }
inline void rewind() inline void rewind()
{ {
seek(100); seek(100);
} }
inline void seek(std::streampos pos) inline void seek(std::streampos pos)
{ {
file_.seekg(pos,std::ios::beg); file_.seekg(pos,std::ios::beg);
} }
inline std::streampos pos() inline std::streampos pos()
{ {
return file_.tellg(); return file_.tellg();
} }
inline bool is_eof() inline bool is_eof()
{ {
return file_.eof(); return file_.eof();