00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifndef __DBCONN_H_
00023 #define __DBCONN_H_
00024
00025 #include <libpq-fe.h>
00026 #include <libplayercore/playercore.h>
00027 #include <libplayerwkb/playerwkb.h>
00028 #include <vector>
00029 #include <string>
00030 #include <cstring>
00031 #include <cstddef>
00032
00033 #define MAX_PSQL_STRING 256
00034
00035 using namespace std;
00036
00037 typedef struct
00038 {
00039 double x0, y0, x1, y1;
00040 } BoundingBox;
00041
00042 #define BBOX(ptr) (reinterpret_cast<BoundingBox *>(ptr))
00043
00044 class FeatureDataHolder
00045 {
00046 public:
00047 FeatureDataHolder() { memset(&feature_data, 0, sizeof feature_data); }
00048 FeatureDataHolder(const FeatureDataHolder & orig)
00049 {
00050 memset(&feature_data, 0, sizeof feature_data);
00051 name = orig.name;
00052 wkb = orig.wkb;
00053 attrib = orig.attrib;
00054 }
00055 virtual ~FeatureDataHolder();
00056 FeatureDataHolder(string name)
00057 {
00058 memset(&feature_data, 0, sizeof feature_data);
00059 this->name = name;
00060 }
00061 FeatureDataHolder(const player_vectormap_feature_data_t * feature)
00062 {
00063 memset(&feature_data, 0, sizeof feature_data);
00064 name = string(feature->name);
00065 attrib = string(feature->attrib);
00066 wkb.assign(feature->wkb, (feature->wkb) + (feature->wkb_count));
00067 }
00068
00069 const player_vectormap_feature_data_t* Convert();
00070
00071 string name;
00072 vector<uint8_t> wkb;
00073 string attrib;
00074 player_vectormap_feature_data_t feature_data;
00075 };
00076
00077 class LayerInfoHolder
00078 {
00079 public:
00080 LayerInfoHolder() { memset(&layer_info,0,sizeof(layer_info)); memset(&extent, 0, sizeof(extent)); };
00081 LayerInfoHolder(const LayerInfoHolder & orig)
00082 {
00083 memset(&layer_info,0,sizeof(layer_info));
00084 name = orig.name;
00085 extent = orig.extent;
00086 }
00087 LayerInfoHolder(string name)
00088 {
00089 memset(&layer_info,0,sizeof(layer_info));
00090 this->name = name;
00091 memset(&extent, 0, sizeof(extent));
00092 };
00093 virtual ~LayerInfoHolder()
00094 {
00095 free(layer_info.name);
00096 }
00097
00098 const player_vectormap_layer_info_t* Convert();
00099
00100 string name;
00101 BoundingBox extent;
00102 player_vectormap_layer_info_t layer_info;
00103 };
00104
00105 class LayerDataHolder
00106 {
00107 public:
00108 LayerDataHolder() { memset(&layer_data, 0, sizeof layer_data); }
00109 LayerDataHolder(const LayerDataHolder & orig)
00110 {
00111 memset(&layer_data, 0, sizeof layer_data);
00112 name = orig.name;
00113 features = orig.features;
00114 }
00115 LayerDataHolder(string name)
00116 {
00117 memset(&layer_data,0,sizeof(layer_data));
00118 this->name = name;
00119 }
00120 LayerDataHolder(const player_vectormap_layer_data_t * layer)
00121 {
00122 memset(&layer_data, 0, sizeof layer_data);
00123 name = string(layer->name);
00124 for (uint32_t ii = 0; ii < layer->features_count; ii++)
00125 {
00126 FeatureDataHolder fd(&(layer->features[ii]));
00127 features.push_back(fd);
00128 }
00129 }
00130 virtual ~LayerDataHolder();
00131
00132 const player_vectormap_layer_data_t* Convert();
00133
00134 vector<FeatureDataHolder> features;
00135 player_vectormap_layer_data_t layer_data;
00136 string name;
00137 };
00138
00139 class VectorMapInfoHolder
00140 {
00141 public:
00142 VectorMapInfoHolder() { memset(&info, 0, sizeof info); memset(&extent, 0, sizeof extent); };
00143 VectorMapInfoHolder(const VectorMapInfoHolder & orig)
00144 {
00145 memset(&info, 0, sizeof info);
00146 srid = orig.srid; layers = orig.layers; extent = orig.extent;
00147 }
00148 virtual ~VectorMapInfoHolder();
00149 VectorMapInfoHolder(uint32_t srid, BoundingBox extent)
00150 {
00151 this->srid = srid; this->extent = extent;
00152 memset(&info, 0, sizeof info);
00153 };
00154
00155 const player_vectormap_info_t* Convert();
00156
00157 uint32_t srid;
00158 vector<LayerInfoHolder> layers;
00159 BoundingBox extent;
00160 player_vectormap_info_t info;
00161 };
00162
00163 class PostgresConn
00164 {
00165 public:
00166 PostgresConn(int debug = 0){ this->wkbprocessor = player_wkb_create_processor(); this->conn = NULL; this->debug = debug; };
00167 virtual ~PostgresConn(){ if (Connected()) Disconnect(); player_wkb_destroy_processor(this->wkbprocessor); };
00168 bool Connect(const char* dbname, const char* host, const char* user, const char* password, const char* port);
00169 bool Disconnect();
00170 bool Connected() { return (conn != NULL) && (PQstatus(conn) != CONNECTION_BAD); };
00171
00172 VectorMapInfoHolder GetVectorMapInfo(vector<string> layerNames);
00173 LayerInfoHolder GetLayerInfo(const char *layer_name);
00174 LayerDataHolder GetLayerData(const char *layer_name);
00175 int WriteLayerData(LayerDataHolder & data);
00176
00177 private:
00178 BoundingBox BinaryToBBox(const uint8_t *binary, uint32_t length);
00179 uint32_t Text2Bin(const char * text, unsigned char * bin, uint32_t maxlen);
00180 playerwkbprocessor_t wkbprocessor;
00181 PGconn *conn;
00182 int debug;
00183 static void bbcb(void * bbox, double x0, double y0, double x1, double y1);
00184 };
00185
00186 #endif