serialize.hh revision 56
1/* 2 * Copyright (c) 2003 The Regents of The University of Michigan 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer; 9 * redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution; 12 * neither the name of the copyright holders nor the names of its 13 * contributors may be used to endorse or promote products derived from 14 * this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29/* @file 30 * Serialization Interface Declarations 31 */ 32 33#ifndef __SERIALIZE_HH__ 34#define __SERIALIZE_HH__ 35 36 37#include <list> 38#include <iostream> 39 40#include "sim/host.hh" 41#include "sim/configfile.hh" 42 43class IniFile; 44 45/* 46 * Basic support for object serialization. 47 */ 48class Serializeable 49{ 50 public: 51 // To allow other classes to do some of the serialization work. 52 class Proxy { 53 private: 54 Serializeable *obj; 55 56 // Make it so only Serializables can construct one of these. 57 Proxy(Serializeable *o) : obj(o) {}; 58 59 friend class Serializeable; 60 61 public: 62 template <class T> 63 void paramOut(const std::string &name, const T& param) const { 64 obj->paramOut(name, param); 65 }; 66 }; 67 68 friend class Serializer; 69 friend class Proxy; 70 71 private: 72 Proxy proxy; 73 74 protected: 75 const Proxy &getProxy() { return(proxy); }; 76 77 // object name: should be unique 78 std::string objName; 79 80 bool serialized; 81 static Serializer *serializer; 82 83 void mark(); 84 void nameOut(); 85 void nameOut(const std::string &_name); 86 void childOut(const std::string &name, Serializeable *child); 87 template <class T> 88 void paramOut(const std::string &name, const T& param); 89 90 std::ostream &out() const; 91 92 public: 93 Serializeable(const std::string &n); 94 virtual ~Serializeable(); 95 96 void setName(const std::string &name); 97 98 // return name 99 const std::string &name() const { return objName; } 100 101 virtual void nameChildren() {} 102 virtual void serialize() {} 103 virtual void unserialize(IniFile &db, const std::string &category, 104 ConfigNode *node = NULL) 105 { 106 std::cout << name() << " is being unserialized" << std::endl; 107 } 108}; 109 110class Serializer 111{ 112 friend class Serializeable; 113 114 protected: 115 typedef std::list<Serializeable *> serlist_t; 116 serlist_t objects; 117 std::string file; 118 std::ostream *output; 119 std::ostream &out() const; 120 121 public: 122 Serializer(); 123 virtual ~Serializer(); 124 125 private: 126 void add_object(Serializeable *obj); 127 void add_objects(); 128 129 public: 130 void serialize(const std::string &file); 131 const std::string &filename() const { return file; } 132}; 133 134template <class T> 135inline void 136Serializeable::paramOut(const std::string &name, const T& param) 137{ 138 out() << name << "=" << param << "\n"; 139} 140 141template <> void 142Serializeable::paramOut(const std::string &name, const uint64_t& param); 143 144 145// 146// A SerializeableBuilder serves as an evaluation context for a set of 147// parameters that describe a specific instance of a Serializeable. This 148// evaluation context corresponds to a section in the .ini file (as 149// with the base ParamContext) plus an optional node in the 150// configuration hierarchy (the configNode member) for resolving 151// Serializeable references. SerializeableBuilder is an abstract superclass; 152// derived classes specialize the class for particular subclasses of 153// Serializeable (e.g., BaseCache). 154// 155// For typical usage, see the definition of 156// SerializeableClass::createObject(). 157// 158class SerializeableBuilder 159{ 160 public: 161 162 SerializeableBuilder() {} 163 164 virtual ~SerializeableBuilder() {} 165 166 // Create the actual Serializeable corresponding to the parameter 167 // values in this context. This function is overridden in derived 168 // classes to call a specific constructor for a particular 169 // subclass of Serializeable. 170 virtual Serializeable *create() = 0; 171}; 172 173// 174// An instance of SerializeableClass corresponds to a class derived from 175// Serializeable. The SerializeableClass instance serves to bind the string 176// name (found in the config file) to a function that creates an 177// instance of the appropriate derived class. 178// 179// This would be much cleaner in Smalltalk or Objective-C, where types 180// are first-class objects themselves. 181// 182class SerializeableClass 183{ 184 public: 185 186 // Type CreateFunc is a pointer to a function that creates a new 187 // simulation object builder based on a .ini-file parameter 188 // section (specified by the first string argument), a unique name 189 // for the object (specified by the second string argument), and 190 // an optional config hierarchy node (specified by the third 191 // argument). A pointer to the new SerializeableBuilder is returned. 192 typedef SerializeableBuilder *(*CreateFunc)(); 193 194 static std::map<std::string,CreateFunc> *classMap; 195 196 // Constructor. For example: 197 // 198 // SerializeableClass baseCacheSerializeableClass("BaseCacheSerializeable", 199 // newBaseCacheSerializeableBuilder); 200 // 201 SerializeableClass(const std::string &className, CreateFunc createFunc); 202 203 // create Serializeable given name of class and pointer to 204 // configuration hierarchy node 205 static Serializeable *createObject(IniFile &configDB, 206 const std::string &configClassName); 207 208}; 209 210// 211// Macros to encapsulate the magic of declaring & defining 212// SerializeableBuilder and SerializeableClass objects 213// 214 215#define CREATE_SERIALIZEABLE(OBJ_CLASS) \ 216OBJ_CLASS *OBJ_CLASS##Builder::create() 217 218#define REGISTER_SERIALIZEABLE(CLASS_NAME, OBJ_CLASS) \ 219class OBJ_CLASS##Builder : public SerializeableBuilder \ 220{ \ 221 public: \ 222 \ 223 OBJ_CLASS##Builder() {} \ 224 virtual ~OBJ_CLASS##Builder() {} \ 225 \ 226 OBJ_CLASS *create(); \ 227}; \ 228 \ 229 \ 230SerializeableBuilder * \ 231new##OBJ_CLASS##Builder() \ 232{ \ 233 return new OBJ_CLASS##Builder(); \ 234} \ 235 \ 236SerializeableClass the##OBJ_CLASS##Class(CLASS_NAME, \ 237 new##OBJ_CLASS##Builder); 238 239 240 241#endif // __SERIALIZE_HH__ 242