Osmium  0.1
include/osmium/storage/objectstore.hpp
Go to the documentation of this file.
00001 #ifndef OSMIUM_STORAGE_OBJECTSTORE_HPP
00002 #define OSMIUM_STORAGE_OBJECTSTORE_HPP
00003 
00004 /*
00005 
00006 Copyright 2011 Jochen Topf <jochen@topf.org> and others (see README).
00007 
00008 This file is part of Osmium (https://github.com/joto/osmium).
00009 
00010 Osmium is free software: you can redistribute it and/or modify it under the
00011 terms of the GNU Lesser General Public License or (at your option) the GNU
00012 General Public License as published by the Free Software Foundation, either
00013 version 3 of the Licenses, or (at your option) any later version.
00014 
00015 Osmium is distributed in the hope that it will be useful, but WITHOUT ANY
00016 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
00017 PARTICULAR PURPOSE. See the GNU Lesser General Public License and the GNU
00018 General Public License for more details.
00019 
00020 You should have received a copy of the Licenses along with Osmium. If not, see
00021 <http://www.gnu.org/licenses/>.
00022 
00023 */
00024 
00025 #include <set>
00026 #include <boost/bind.hpp>
00027 
00028 #include <osmium/handler.hpp>
00029 
00030 namespace Osmium {
00031 
00032     namespace Storage {
00033 
00046         class ObjectStore : public Osmium::Handler::Base {
00047 
00048         public:
00049 
00050             ObjectStore() : Base(), m_nodes(), m_ways(), m_relations() {
00051             }
00052 
00056             void node(const shared_ptr<Osmium::OSM::Node const>& node) {
00057                 m_nodes.insert(node);
00058             }
00059 
00063             void way(const shared_ptr<Osmium::OSM::Way const>& way) {
00064                 m_ways.insert(way);
00065             }
00066 
00070             void relation(const shared_ptr<Osmium::OSM::Relation const>& relation) {
00071                 m_relations.insert(relation);
00072             }
00073 
00077             void clear_nodes() {
00078                 m_nodes.clear();
00079             }
00080 
00084             void clear_ways() {
00085                 m_ways.clear();
00086             }
00087 
00091             void clear_relations() {
00092                 m_relations.clear();
00093             }
00094 
00098             void clear() {
00099                 clear_nodes();
00100                 clear_ways();
00101                 clear_relations();
00102             }
00103 
00118             template <class THandler>
00119             void feed_to(THandler* handler, Osmium::OSM::Meta& meta, bool clear=true) {
00120                 handler->init(meta);
00121 
00122                 handler->before_nodes();
00123                 std::for_each(m_nodes.begin(), m_nodes.end(), boost::bind(&THandler::node, handler, _1));
00124                 handler->after_nodes();
00125                 if (clear) {
00126                     clear_nodes();
00127                 }
00128 
00129                 handler->before_ways();
00130                 std::for_each(m_ways.begin(), m_ways.end(), boost::bind(&THandler::way, handler, _1));
00131                 handler->after_ways();
00132                 if (clear) {
00133                     clear_ways();
00134                 }
00135 
00136                 handler->before_relations();
00137                 std::for_each(m_relations.begin(), m_relations.end(), boost::bind(&THandler::relation, handler, _1));
00138                 handler->after_relations();
00139                 if (clear) {
00140                     clear_relations();
00141                 }
00142 
00143                 handler->final();
00144             }
00145 
00146         private:
00147 
00148             typedef std::set<shared_ptr<Osmium::OSM::Node const>     > nodeset;
00149             typedef std::set<shared_ptr<Osmium::OSM::Way const>      > wayset;
00150             typedef std::set<shared_ptr<Osmium::OSM::Relation const> > relationset;
00151 
00152             nodeset     m_nodes;
00153             wayset      m_ways;
00154             relationset m_relations;
00155 
00156         public:
00157 
00165             template <class THandler>
00166             class ApplyHandler : public Osmium::Handler::Forward<THandler> {
00167 
00168             public:
00169 
00170                 ApplyHandler(ObjectStore& os, THandler* handler, Osmium::OSM::Meta& meta) :
00171                     Osmium::Handler::Forward<THandler>(handler),
00172                     m_object_store(os),
00173                     m_handler(handler),
00174                     m_meta(meta),
00175                     m_nodes_iter(os.m_nodes.begin()),
00176                     m_nodes_end(os.m_nodes.end()),
00177                     m_ways_iter(os.m_ways.begin()),
00178                     m_ways_end(os.m_ways.end()),
00179                     m_relations_iter(os.m_relations.begin()),
00180                     m_relations_end(os.m_relations.end()) {
00181                 }
00182 
00183                 void init(const Osmium::OSM::Meta&) {
00184                     m_handler->init(m_meta);
00185                 }
00186 
00187                 void node(const shared_ptr<Osmium::OSM::Node>& node) {
00188                     while (m_nodes_iter != m_nodes_end && **m_nodes_iter < *node) {
00189                         m_handler->node(*m_nodes_iter++);
00190                     }
00191                     m_handler->node(node);
00192                 }
00193 
00194                 void after_nodes() {
00195                     while (m_nodes_iter != m_nodes_end) {
00196                         m_handler->node(*m_nodes_iter++);
00197                     }
00198                     m_handler->after_nodes();
00199                     m_object_store.clear_nodes();
00200                 }
00201 
00202                 void way(const shared_ptr<Osmium::OSM::Way>& way) {
00203                     while (m_ways_iter != m_ways_end && **m_ways_iter < *way) {
00204                         m_handler->way(*m_ways_iter++);
00205                     }
00206                     m_handler->way(way);
00207                 }
00208 
00209                 void after_ways() {
00210                     while (m_ways_iter != m_ways_end) {
00211                         m_handler->way(*m_ways_iter++);
00212                     }
00213                     m_handler->after_ways();
00214                     m_object_store.clear_ways();
00215                 }
00216 
00217                 void relation(const shared_ptr<Osmium::OSM::Relation>& relation) {
00218                     while (m_relations_iter != m_relations_end && **m_relations_iter < *relation) {
00219                         m_handler->relation(*m_relations_iter++);
00220                     }
00221                     m_handler->relation(relation);
00222                 }
00223 
00224                 void after_relations() {
00225                     while (m_relations_iter != m_relations_end) {
00226                         m_handler->relation(*m_relations_iter++);
00227                     }
00228                     m_handler->after_relations();
00229                     m_object_store.clear_relations();
00230                 }
00231 
00232             private:
00233 
00234                 ObjectStore& m_object_store;
00235                 THandler* m_handler;
00236                 Osmium::OSM::Meta& m_meta;
00237 
00238                 ObjectStore::nodeset::iterator     m_nodes_iter;
00239                 ObjectStore::nodeset::iterator     m_nodes_end;
00240                 ObjectStore::wayset::iterator      m_ways_iter;
00241                 ObjectStore::wayset::iterator      m_ways_end;
00242                 ObjectStore::relationset::iterator m_relations_iter;
00243                 ObjectStore::relationset::iterator m_relations_end;
00244 
00245             }; // class ApplyHandler
00246 
00247         }; // class ObjectStore
00248 
00249     } // namespace Storage
00250 
00251 } // namespace Osmium
00252 
00253 #endif // OSMIUM_STORAGE_OBJECTSTORE_HPP
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines