dbconn.h
00001 /*
00002  *  Player - One Hell of a Robot Server
00003  *  Copyright (C) 2007
00004  *     Ben Morelli
00005  *
00006  *
00007  *  This library is free software; you can redistribute it and/or
00008  *  modify it under the terms of the GNU Lesser General Public
00009  *  License as published by the Free Software Foundation; either
00010  *  version 2.1 of the License, or (at your option) any later version.
00011  *
00012  *  This library is distributed in the hope that it will be useful,
00013  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  *  Lesser General Public License for more details.
00016  *
00017  *  You should have received a copy of the GNU Lesser General Public
00018  *  License along with this library; if not, write to the Free Software
00019  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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 /* __DBCONN_H_ */

Last updated 12 September 2005 21:38:45