gem5/sim/serialize.hh
Steve Reinhardt 25693e9e69 Make include paths explicit and update makefile accordingly.
arch/alpha/alpha_memory.cc:
arch/alpha/alpha_memory.hh:
arch/alpha/arguments.cc:
arch/alpha/arguments.hh:
arch/alpha/ev5.cc:
arch/alpha/ev5.hh:
arch/alpha/fake_syscall.cc:
arch/alpha/faults.cc:
arch/alpha/isa_desc:
arch/alpha/isa_traits.hh:
arch/alpha/osfpal.cc:
arch/alpha/vtophys.cc:
arch/alpha/vtophys.hh:
base/circlebuf.cc:
base/compression/lzss_compression.cc:
base/compression/lzss_compression.hh:
base/cprintf.cc:
base/cprintf.hh:
base/fast_alloc.cc:
base/fifo_buffer.cc:
base/fifo_buffer.hh:
base/hashmap.hh:
base/hostinfo.cc:
base/hostinfo.hh:
base/hybrid_pred.cc:
base/hybrid_pred.hh:
base/inet.cc:
base/inet.hh:
base/inifile.cc:
base/inifile.hh:
base/intmath.cc:
base/loader/aout_object.cc:
base/loader/aout_object.hh:
base/loader/ecoff_object.cc:
base/loader/ecoff_object.hh:
base/loader/elf_object.cc:
base/loader/elf_object.hh:
base/loader/exec_aout.h:
base/loader/exec_ecoff.h:
base/loader/object_file.cc:
base/loader/object_file.hh:
base/loader/symtab.cc:
base/loader/symtab.hh:
base/misc.cc:
base/misc.hh:
base/pollevent.cc:
base/pollevent.hh:
base/random.cc:
base/random.hh:
base/range.hh:
base/remote_gdb.cc:
base/remote_gdb.hh:
base/res_list.hh:
base/sat_counter.cc:
base/sat_counter.hh:
base/sched_list.hh:
base/socket.cc:
base/statistics.cc:
base/statistics.hh:
base/str.cc:
base/trace.cc:
base/trace.hh:
cpu/base_cpu.cc:
cpu/base_cpu.hh:
cpu/exec_context.cc:
cpu/exec_context.hh:
cpu/exetrace.cc:
cpu/exetrace.hh:
cpu/intr_control.cc:
cpu/intr_control.hh:
cpu/memtest/memtest.cc:
cpu/memtest/memtest.hh:
cpu/pc_event.cc:
cpu/pc_event.hh:
cpu/simple_cpu/simple_cpu.cc:
cpu/simple_cpu/simple_cpu.hh:
cpu/static_inst.cc:
cpu/static_inst.hh:
dev/alpha_console.cc:
dev/alpha_console.hh:
dev/console.cc:
dev/console.hh:
dev/disk_image.cc:
dev/disk_image.hh:
dev/etherbus.cc:
dev/etherbus.hh:
dev/etherdump.cc:
dev/etherdump.hh:
dev/etherint.cc:
dev/etherint.hh:
dev/etherlink.cc:
dev/etherlink.hh:
dev/etherpkt.hh:
dev/ethertap.cc:
dev/ethertap.hh:
dev/simple_disk.cc:
dev/simple_disk.hh:
kern/tru64/tru64_syscalls.cc:
kern/tru64/tru64_syscalls.hh:
sim/debug.cc:
sim/eventq.cc:
sim/eventq.hh:
sim/main.cc:
sim/param.cc:
sim/param.hh:
sim/prog.cc:
sim/prog.hh:
sim/serialize.cc:
sim/serialize.hh:
sim/sim_events.cc:
sim/sim_events.hh:
sim/sim_object.cc:
sim/sim_object.hh:
sim/sim_time.cc:
sim/system.cc:
sim/system.hh:
sim/universe.cc:
test/circletest.cc:
test/cprintftest.cc:
test/initest.cc:
test/nmtest.cc:
test/offtest.cc:
test/paramtest.cc:
test/rangetest.cc:
test/stattest.cc:
test/strnumtest.cc:
test/symtest.cc:
test/tokentest.cc:
test/tracetest.cc:
util/tap/tap.cc:
    Make include paths explicit.

--HG--
extra : convert_revision : 941cbdc591fd4d3d1d9f095cd58fc23dd2d73840
2003-10-10 11:09:00 -07:00

241 lines
7.4 KiB
C++

/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* @file
* Serialization Interface Declarations
*/
#ifndef __SERIALIZE_HH__
#define __SERIALIZE_HH__
#include <list>
#include <iostream>
#include "sim/host.hh"
#include "sim/configfile.hh"
class IniFile;
/*
* Basic support for object serialization.
*/
class Serializeable
{
public:
// To allow other classes to do some of the serialization work.
class Proxy {
private:
Serializeable *obj;
// Make it so only Serializables can construct one of these.
Proxy(Serializeable *o) : obj(o) {};
friend class Serializeable;
public:
template <class T>
void paramOut(const std::string &name, const T& param) const {
obj->paramOut(name, param);
};
};
friend class Serializer;
friend class Proxy;
private:
Proxy proxy;
protected:
const Proxy &getProxy() { return(proxy); };
// object name: should be unique
std::string objName;
bool serialized;
static Serializer *serializer;
void mark();
void nameOut();
void nameOut(const std::string &_name);
void childOut(const std::string &name, Serializeable *child);
template <class T>
void paramOut(const std::string &name, const T& param);
std::ostream &out() const;
public:
Serializeable(const std::string &n);
virtual ~Serializeable();
void setName(const std::string &name);
// return name
const std::string &name() const { return objName; }
virtual void nameChildren() {}
virtual void serialize() {}
virtual void unserialize(IniFile &db, const std::string &category,
ConfigNode *node = NULL)
{
std::cout << name() << " is being unserialized" << std::endl;
}
};
class Serializer
{
friend class Serializeable;
protected:
typedef std::list<Serializeable *> serlist_t;
serlist_t objects;
std::string file;
std::ostream *output;
std::ostream &out() const;
public:
Serializer();
virtual ~Serializer();
private:
void add_object(Serializeable *obj);
void add_objects();
public:
void serialize(const std::string &file);
const std::string &filename() const { return file; }
};
template <class T>
inline void
Serializeable::paramOut(const std::string &name, const T& param)
{
out() << name << "=" << param << "\n";
}
template <> void
Serializeable::paramOut(const std::string &name, const uint64_t& param);
//
// A SerializeableBuilder serves as an evaluation context for a set of
// parameters that describe a specific instance of a Serializeable. This
// evaluation context corresponds to a section in the .ini file (as
// with the base ParamContext) plus an optional node in the
// configuration hierarchy (the configNode member) for resolving
// Serializeable references. SerializeableBuilder is an abstract superclass;
// derived classes specialize the class for particular subclasses of
// Serializeable (e.g., BaseCache).
//
// For typical usage, see the definition of
// SerializeableClass::createObject().
//
class SerializeableBuilder
{
public:
SerializeableBuilder() {}
virtual ~SerializeableBuilder() {}
// Create the actual Serializeable corresponding to the parameter
// values in this context. This function is overridden in derived
// classes to call a specific constructor for a particular
// subclass of Serializeable.
virtual Serializeable *create() = 0;
};
//
// An instance of SerializeableClass corresponds to a class derived from
// Serializeable. The SerializeableClass instance serves to bind the string
// name (found in the config file) to a function that creates an
// instance of the appropriate derived class.
//
// This would be much cleaner in Smalltalk or Objective-C, where types
// are first-class objects themselves.
//
class SerializeableClass
{
public:
// Type CreateFunc is a pointer to a function that creates a new
// simulation object builder based on a .ini-file parameter
// section (specified by the first string argument), a unique name
// for the object (specified by the second string argument), and
// an optional config hierarchy node (specified by the third
// argument). A pointer to the new SerializeableBuilder is returned.
typedef SerializeableBuilder *(*CreateFunc)();
static std::map<std::string,CreateFunc> *classMap;
// Constructor. For example:
//
// SerializeableClass baseCacheSerializeableClass("BaseCacheSerializeable",
// newBaseCacheSerializeableBuilder);
//
SerializeableClass(const std::string &className, CreateFunc createFunc);
// create Serializeable given name of class and pointer to
// configuration hierarchy node
static Serializeable *createObject(IniFile &configDB,
const std::string &configClassName);
};
//
// Macros to encapsulate the magic of declaring & defining
// SerializeableBuilder and SerializeableClass objects
//
#define CREATE_SERIALIZEABLE(OBJ_CLASS) \
OBJ_CLASS *OBJ_CLASS##Builder::create()
#define REGISTER_SERIALIZEABLE(CLASS_NAME, OBJ_CLASS) \
class OBJ_CLASS##Builder : public SerializeableBuilder \
{ \
public: \
\
OBJ_CLASS##Builder() {} \
virtual ~OBJ_CLASS##Builder() {} \
\
OBJ_CLASS *create(); \
}; \
\
\
SerializeableBuilder * \
new##OBJ_CLASS##Builder() \
{ \
return new OBJ_CLASS##Builder(); \
} \
\
SerializeableClass the##OBJ_CLASS##Class(CLASS_NAME, \
new##OBJ_CLASS##Builder);
#endif // __SERIALIZE_HH__