lsst.daf.persistence  15.0-6-g4cfb9db
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 
60 Persistence::Persistence(lsst::pex::policy::Policy::Ptr policy) :
61  lsst::daf::base::Citizen(typeid(*this)), _policy(policy) {
62 }
63 
67 }
68 
76 FormatterStorage::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 FormatterStorage::createInstance(storageType, location, persist, policyPtr);
84 }
85 
92  LogicalLocation const& location) {
93  return _getStorage(storageType, location, true);
94 }
95 
102  LogicalLocation const& location) {
103  return _getStorage(storageType, location, false);
104 }
105 
113  lsst::daf::base::Persistable const& persistable, FormatterStorage::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 FormatterStorage
125  // in turn. Commit the transactions (in order) when all writing is
126  // complete.
127  for (FormatterStorage::List::const_iterator it = storageList.begin();
128  it != storageList.end(); ++it) {
129  (*it)->startTransaction();
130  f->write(&persistable, *it, additionalData);
131  }
132  for (FormatterStorage::List::const_iterator it = storageList.begin();
133  it != storageList.end(); ++it) {
134  (*it)->endTransaction();
135  }
136 }
137 
148  std::string const& persistableType, FormatterStorage::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 FormatterStorage; then update
159  // from each additional FormatterStorage in turn.
160  lsst::daf::base::Persistable* persistable = 0;
161  for (FormatterStorage::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 (FormatterStorage::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, FormatterStorage::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
static Ptr getPersistence(lsst::pex::policy::Policy::Ptr policy)
Create a Persistence object.
Definition: Persistence.cc:196
#define __attribute__(x)
Definition: Persistence.cc:39
Interface for FormatterStorage abstract base class.
Class for logical location of a persisted Persistable instance.
virtual void persist(lsst::daf::base::Persistable const &persistable, FormatterStorage::List const &storageList, lsst::daf::base::PropertySet::Ptr additionalData)
Persist a Persistable instance.
Definition: Persistence.cc:112
lsst::pex::policy::Policy::Ptr getPolicy() const
Return the policy used to configure the Persistence object.
Definition: Persistence.cc:205
virtual ~Persistence(void)
Destructor.
Definition: Persistence.cc:66
T end(T... args)
Class implementing object persistence.
Definition: Persistence.h:68
STL class.
Interface for Formatter abstract base class.
virtual FormatterStorage::Ptr getRetrieveStorage(std::string const &storageType, LogicalLocation const &location)
Create a FormatterStorage subclass configured to retrieve from a location.
Definition: Persistence.cc:101
virtual FormatterStorage::Ptr getPersistStorage(std::string const &storageType, LogicalLocation const &location)
Create a FormatterStorage subclass configured to persist to a location.
Definition: Persistence.cc:91
static Formatter::Ptr lookupFormatter(std::string const &persistableType, lsst::pex::policy::Policy::Ptr policy)
Lookup Formatter subclass by name of Persistable subclass.
Definition: Formatter.cc:84
virtual lsst::daf::base::Persistable * unsafeRetrieve(std::string const &persistableType, FormatterStorage::List const &storageList, lsst::daf::base::PropertySet::Ptr additionalData)
Retrieve a Persistable instance, returning an unsafe bare pointer.
Definition: Persistence.cc:147
static Ptr createInstance(std::string const &name, LogicalLocation const &location, bool persist, lsst::pex::policy::Policy::Ptr policy)
Create and configure a FormatterStorage subclass instance.
STL class.
Interface for Persistence class.
T begin(T... args)
std::shared_ptr< Persistence > Ptr
Definition: Persistence.h:70
std::shared_ptr< Persistable > Ptr
virtual lsst::daf::base::Persistable::Ptr retrieve(std::string const &persistableType, FormatterStorage::List const &storageList, lsst::daf::base::PropertySet::Ptr additionalData)
Retrieve a Persistable instance.
Definition: Persistence.cc:185
Interface for LogicalLocation class.