dbconn.h
1/*
2 * Player - One Hell of a Robot Server
3 * Copyright (C) 2007
4 * Ben Morelli
5 *
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#ifndef __DBCONN_H_
23#define __DBCONN_H_
24
25#include <libpq-fe.h>
26#include <libplayercore/playercore.h>
27#include <libplayerwkb/playerwkb.h>
28#include <vector>
29#include <string>
30#include <cstring>
31#include <cstddef>
32
33#define MAX_PSQL_STRING 256
34
35using namespace std;
36
37typedef struct
38{
39 double x0, y0, x1, y1;
41
42#define BBOX(ptr) (reinterpret_cast<BoundingBox *>(ptr))
43
45{
46 public:
47 FeatureDataHolder() { memset(&feature_data, 0, sizeof feature_data); }
49 {
50 memset(&feature_data, 0, sizeof feature_data);
51 name = orig.name;
52 wkb = orig.wkb;
53 attrib = orig.attrib;
54 }
55 virtual ~FeatureDataHolder();
56 FeatureDataHolder(string name)
57 {
58 memset(&feature_data, 0, sizeof feature_data);
59 this->name = name;
60 }
61 FeatureDataHolder(const player_vectormap_feature_data_t * feature)
62 {
63 memset(&feature_data, 0, sizeof feature_data);
64 name = string(feature->name);
65 attrib = string(feature->attrib);
66 wkb.assign(feature->wkb, (feature->wkb) + (feature->wkb_count));
67 }
68
69 const player_vectormap_feature_data_t* Convert();
70
71 string name;
72 vector<uint8_t> wkb;
73 string attrib;
74 player_vectormap_feature_data_t feature_data;
75};
76
78{
79 public:
80 LayerInfoHolder() { memset(&layer_info,0,sizeof(layer_info)); memset(&extent, 0, sizeof(extent)); };
82 {
83 memset(&layer_info,0,sizeof(layer_info));
84 name = orig.name;
85 extent = orig.extent;
86 }
87 LayerInfoHolder(string name)
88 {
89 memset(&layer_info,0,sizeof(layer_info));
90 this->name = name;
91 memset(&extent, 0, sizeof(extent));
92 };
93 virtual ~LayerInfoHolder()
94 {
95 free(layer_info.name);
96 }
97
98 const player_vectormap_layer_info_t* Convert();
99
100 string name;
101 BoundingBox extent;
102 player_vectormap_layer_info_t layer_info;
103};
104
106{
107 public:
108 LayerDataHolder() { memset(&layer_data, 0, sizeof layer_data); }
109 LayerDataHolder(const LayerDataHolder & orig)
110 {
111 memset(&layer_data, 0, sizeof layer_data);
112 name = orig.name;
113 features = orig.features;
114 }
115 LayerDataHolder(string name)
116 {
117 memset(&layer_data,0,sizeof(layer_data));
118 this->name = name;
119 }
120 LayerDataHolder(const player_vectormap_layer_data_t * layer)
121 {
122 memset(&layer_data, 0, sizeof layer_data);
123 name = string(layer->name);
124 for (uint32_t ii = 0; ii < layer->features_count; ii++)
125 {
126 FeatureDataHolder fd(&(layer->features[ii]));
127 features.push_back(fd);
128 }
129 }
130 virtual ~LayerDataHolder();
131
132 const player_vectormap_layer_data_t* Convert();
133
134 vector<FeatureDataHolder> features;
135 player_vectormap_layer_data_t layer_data;
136 string name;
137};
138
140{
141 public:
142 VectorMapInfoHolder() { memset(&info, 0, sizeof info); memset(&extent, 0, sizeof extent); };
144 {
145 memset(&info, 0, sizeof info);
146 srid = orig.srid; layers = orig.layers; extent = orig.extent;
147 }
148 virtual ~VectorMapInfoHolder();
149 VectorMapInfoHolder(uint32_t srid, BoundingBox extent)
150 {
151 this->srid = srid; this->extent = extent;
152 memset(&info, 0, sizeof info);
153 };
154
155 const player_vectormap_info_t* Convert();
156
157 uint32_t srid;
158 vector<LayerInfoHolder> layers;
159 BoundingBox extent;
160 player_vectormap_info_t info;
161};
162
164{
165 public:
166 PostgresConn(int debug = 0){ this->wkbprocessor = player_wkb_create_processor(); this->conn = NULL; this->debug = debug; };
167 virtual ~PostgresConn(){ if (Connected()) Disconnect(); player_wkb_destroy_processor(this->wkbprocessor); };
168 bool Connect(const char* dbname, const char* host, const char* user, const char* password, const char* port);
169 bool Disconnect();
170 bool Connected() { return (conn != NULL) && (PQstatus(conn) != CONNECTION_BAD); };
171
172 VectorMapInfoHolder GetVectorMapInfo(vector<string> layerNames);
173 LayerInfoHolder GetLayerInfo(const char *layer_name);
174 LayerDataHolder GetLayerData(const char *layer_name);
175 int WriteLayerData(LayerDataHolder & data);
176
177 private:
178 BoundingBox BinaryToBBox(const uint8_t *binary, uint32_t length);
179 uint32_t Text2Bin(const char * text, unsigned char * bin, uint32_t maxlen);
180 playerwkbprocessor_t wkbprocessor;
181 PGconn *conn;
182 int debug;
183 static void bbcb(void * bbox, double x0, double y0, double x1, double y1);
184};
185
186#endif /* __DBCONN_H_ */
Definition dbconn.h:45
const player_vectormap_feature_data_t * Convert()
Definition dbconn.cc:389
Definition dbconn.h:106
Definition dbconn.h:78
Definition dbconn.h:164
Definition dbconn.h:140
Definition dbconn.h:38