LSSTApplications  10.0-2-g4f67435,11.0.rc2+1,11.0.rc2+12,11.0.rc2+3,11.0.rc2+4,11.0.rc2+5,11.0.rc2+6,11.0.rc2+7,11.0.rc2+8
LSSTDataManagementBasePackage
Persistence.cc
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 
3 /*
4  * LSST Data Management System
5  * Copyright 2008, 2009, 2010 LSST Corporation.
6  *
7  * This product includes software developed by the
8  * LSST Project (http://www.lsst.org/).
9  *
10  * This program is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the LSST License Statement and
21  * the GNU General Public License along with this program. If not,
22  * see <http://www.lsstcorp.org/LegalNotices/>.
23  */
24 
25 
38 #ifndef __GNUC__
39 # define __attribute__(x) /*NOTHING*/
40 #endif
41 static char const* SVNid __attribute__((unused)) = "$Id$";
42 
44 
45 #include <boost/regex.hpp>
46 
50 #include "lsst/pex/policy/Policy.h"
52 
53 namespace lsst {
54 namespace daf {
55 namespace persistence {
56 
61  lsst::daf::base::Citizen(typeid(*this)), _policy(policy) {
62 }
63 
67 }
68 
76 Storage::Ptr Persistence::_getStorage(std::string const& storageType,
77  LogicalLocation const& location,
78  bool persist) {
80  if (_policy && _policy->exists(storageType)) {
81  policyPtr = _policy->getPolicy(storageType);
82  }
83  return Storage::createInstance(storageType, location, persist, policyPtr);
84 }
85 
91 Storage::Ptr Persistence::getPersistStorage(std::string const& storageType,
92  LogicalLocation const& location) {
93  return _getStorage(storageType, location, true);
94 }
95 
101 Storage::Ptr Persistence::getRetrieveStorage(std::string const& storageType,
102  LogicalLocation const& location) {
103  return _getStorage(storageType, location, false);
104 }
105 
113  lsst::daf::base::Persistable const& persistable, Storage::List const& storageList,
114  lsst::daf::base::PropertySet::Ptr additionalData) {
115  // Get the policies for all Formatters, if present
116  std::string policyName = "Formatter";
118  if (_policy && _policy->exists(policyName)) {
119  policyPtr = _policy->getPolicy(policyName);
120  }
121  // Find the appropriate Formatter.
122  Formatter::Ptr f =
123  Formatter::lookupFormatter(typeid(persistable), policyPtr);
124  // Use the Formatter instance to write the Persistable to each Storage
125  // in turn. Commit the transactions (in order) when all writing is
126  // complete.
127  for (Storage::List::const_iterator it = storageList.begin();
128  it != storageList.end(); ++it) {
129  (*it)->startTransaction();
130  f->write(&persistable, *it, additionalData);
131  }
132  for (Storage::List::const_iterator it = storageList.begin();
133  it != storageList.end(); ++it) {
134  (*it)->endTransaction();
135  }
136 }
137 
148  std::string const& persistableType, Storage::List const& storageList,
149  lsst::daf::base::PropertySet::Ptr additionalData) {
150  // Get the policies for all Formatters, if present
151  std::string policyName = "Formatter";
153  if (_policy && _policy->exists(policyName)) {
154  policyPtr = _policy->getPolicy(policyName);
155  }
156  // Find the appropriate Formatter.
157  Formatter::Ptr f = Formatter::lookupFormatter(persistableType, policyPtr);
158  // Use the Formatter instance to read from the first Storage; then update
159  // from each additional Storage in turn.
160  lsst::daf::base::Persistable* persistable = 0;
161  for (Storage::List::const_iterator it = storageList.begin();
162  it != storageList.end(); ++it) {
163  (*it)->startTransaction();
164  if (!persistable) {
165  persistable = f->read(*it, additionalData);
166  } else {
167  f->update(persistable, *it, additionalData);
168  }
169  }
170  for (Storage::List::const_iterator it = storageList.begin();
171  it != storageList.end(); ++it) {
172  (*it)->endTransaction();
173  }
174  return persistable;
175 }
176 
186  std::string const& persistableType, Storage::List const& storageList,
187  lsst::daf::base::PropertySet::Ptr additionalData) {
189  unsafeRetrieve(persistableType, storageList, additionalData));
190 }
191 
198  return Persistence::Ptr(new Persistence(policy));
199 }
200 
206 {
207  return _policy;
208 }
209 
210 
211 }}} // namespace lsst::daf::persistence
Persistence(lsst::pex::policy::Policy::Ptr policy)
Definition: Persistence.cc:60
std::vector< Ptr > List
Definition: Storage.h:63
static Ptr getPersistence(lsst::pex::policy::Policy::Ptr policy)
Definition: Persistence.cc:196
#define __attribute__(x)
Definition: Persistence.cc:39
boost::shared_ptr< Formatter > Ptr
Definition: Formatter.h:81
virtual lsst::daf::base::Persistable * unsafeRetrieve(std::string const &persistableType, Storage::List const &storageList, lsst::daf::base::PropertySet::Ptr additionalData)
Definition: Persistence.cc:147
Class for logical location of a persisted Persistable instance.
virtual Storage::Ptr getRetrieveStorage(std::string const &storageType, LogicalLocation const &location)
Definition: Persistence.cc:101
boost::shared_ptr< PropertySet > Ptr
Definition: PropertySet.h:90
Storage::Ptr _getStorage(std::string const &storageType, LogicalLocation const &location, bool persist)
Definition: Persistence.cc:76
virtual lsst::daf::base::Persistable::Ptr retrieve(std::string const &persistableType, Storage::List const &storageList, lsst::daf::base::PropertySet::Ptr additionalData)
Definition: Persistence.cc:185
Interface for Storage abstract base class.
boost::shared_ptr< Policy > Ptr
Definition: Policy.h:172
static Ptr createInstance(std::string const &name, LogicalLocation const &location, bool persist, lsst::pex::policy::Policy::Ptr policy)
Definition: Storage.cc:75
Interface for Persistence class.
lsst::pex::policy::Policy::Ptr _policy
Pointer to Policy used to configure Persistence.
Definition: Persistence.h:103
virtual Storage::Ptr getPersistStorage(std::string const &storageType, LogicalLocation const &location)
Definition: Persistence.cc:91
Interface for Formatter abstract base class.
boost::shared_ptr< Persistable > Ptr
Definition: Persistable.h:76
static Formatter::Ptr lookupFormatter(std::string const &persistableType, lsst::pex::policy::Policy::Ptr policy)
Definition: Formatter.cc:84
boost::shared_ptr< Persistence > Ptr
Definition: Persistence.h:70
Interface for Persistable base class.
virtual void persist(lsst::daf::base::Persistable const &persistable, Storage::List const &storageList, lsst::daf::base::PropertySet::Ptr additionalData)
Definition: Persistence.cc:112
boost::shared_ptr< Storage > Ptr
Definition: Storage.h:62
Base class for all persistable classes.
Definition: Persistable.h:74
Interface for LogicalLocation class.
lsst::pex::policy::Policy::Ptr getPolicy() const
Definition: Persistence.cc:205