Component.h Source File

Back to the index.

Component.h
Go to the documentation of this file.
1 #ifndef COMPONENT_H
2 #define COMPONENT_H
3 
4 /*
5  * Copyright (C) 2007-2010 Anders Gavare. All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  * notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  * 3. The name of the author may not be used to endorse or promote products
16  * derived from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30 
31 #include "misc.h"
32 
33 #include "Checksum.h"
34 #include "SerializationContext.h"
35 #include "StateVariable.h"
36 
37 
38 class AddressDataBus;
39 class Component;
40 class CPUComponent;
41 class GXemul;
42 class RootComponent;
43 class UI;
44 
45 typedef vector< refcount_ptr<Component> > Components;
46 typedef map< string,string > ComponentCreationSettings;
47 
49 {
52 };
53 
54 
55 /**
56  * \brief A %Component is a node in the configuration tree that
57  * makes up an emulation setup.
58  *
59  * The %Component is the core concept in %GXemul. All devices,
60  * CPUs, networks, and so on are components.
61  */
62 class Component
63  : public ReferenceCountable
64 {
65 protected:
66  /**
67  * \brief Base constructor for a %Component.
68  *
69  * See also: the Create() function.
70  *
71  * @param className The name of the component class.
72  * It should be a short, descriptive name.
73  * For e.g. a PCI bus class, it can be "pcibus".
74  * For a MIPS CPU, it can be "mips_cpu".
75  * @param visibleClassName The visible name of the component class.
76  * It should be a short, descriptive name.
77  * For e.g. a PCI bus class, it can be "pcibus".
78  * For a MIPS CPU, it can be "cpu".
79  */
80  Component(const string& className, const string& visibleClassName);
81 
82 public:
83  virtual ~Component() { }
84 
85  /**
86  * \brief Gets the class name of the component.
87  *
88  * @return the class name of the component, e.g. "pcibus" for a PCI
89  * bus component class, or "mips_cpu" for a MIPS CPU.
90  */
91  string GetClassName() const;
92 
93  /**
94  * \brief Gets the visible class name of the component.
95  *
96  * @return the class name of the component, e.g. "pcibus" for a PCI
97  * bus component class, or "cpu" for a MIPS CPU.
98  */
99  string GetVisibleClassName() const;
100 
101  /**
102  * \brief Creates a Component.
103  *
104  * The reason for having this helper, instead of simply calling the
105  * constructor of a specific %Component, is to make templates work
106  * in a reasonable and straight-forward manner. (Note: This concept
107  * of templates is unrelated to the C++ concept of templates. It just
108  * happens to be the same word.)
109  *
110  * E.g. DummyComponent::Create() returns a new DummyComponent, but
111  * TestMIPSMachine::Create() returns a new MachineComponent
112  * (with some pre-defined child components), not a TestMIPS component.
113  */
114 // static refcount_ptr<Component> Create(const ComponentCreateArgs& args);
115 
116  /**
117  * \brief Get attribute information about a Component.
118  *
119  * @param attributeName The attribute name.
120  * @return A string representing the attribute value. The base
121  * implementation returns an empty string; it is up to individual
122  * Components to return other values.
123  */
124  static string GetAttribute(const string& attributeName);
125 
126  /**
127  * \brief Clones the component and all its children.
128  *
129  * The new copy is a complete copy; modifying either the copy or the
130  * original will not affect the other.
131  *
132  * @return A reference counted pointer to the clone.
133  */
134  refcount_ptr<Component> Clone() const;
135 
136  /**
137  * \brief Makes a light clone of the component and all its children.
138  *
139  * Modifying the original component will not affect the component
140  * returned by this function.
141  *
142  * The new copy is <i>not</i> a complete copy. Expensive data
143  * structures are not copied, only "light" data structures. For
144  * example, RAM memory cell contents is not cloned.
145  *
146  * The main purpose of this function is to allow e.g. a single
147  * stepper to take a light clone, run one step, and the compare
148  * the current component tree with the light clone, to see what
149  * was modified in the step.
150  *
151  * @return A const reference counted pointer to the light clone.
152  */
153  const refcount_ptr<Component> LightClone() const;
154 
155  /**
156  * \brief Compare an older clone to the current tree, to find changes.
157  *
158  * Any changes found are written as messages to changeMessages.
159  * Typical use of this function is to input a "light clone" which
160  * is taken before running a single execution step, to find out
161  * any side effects of that execution step.
162  *
163  * @param oldClone The original component tree to compare to.
164  * @param changeMessages An output stream where to send messages.
165  */
166  void DetectChanges(const refcount_ptr<Component>& oldClone,
167  ostream& changeMessages) const;
168 
169  /**
170  * \brief Generates an ASCII tree dump of a component tree.
171  *
172  * @param branchTemplate Used for recursion. Start with an empty
173  * string ("").
174  * @param htmlLinksForClassNames Used to generate HTML links
175  * by 'make documentation'.
176  * @param prefixForComponentUrls Placed before
177  * component/xyz.html in html links to components.
178  * @return An ASCII string containing the tree.
179  */
180  string GenerateTreeDump(const string& branchTemplate,
181  bool htmlLinksForClassNames = false,
182  string prefixForComponentUrls = "") const;
183 
184  /**
185  * \brief Generate details about the component.
186  *
187  * @return A string containing details about the component.
188  */
189  virtual string GenerateDetails() const;
190 
191  /**
192  * \brief Resets the state of this component and all its children.
193  */
194  void Reset();
195 
196  /**
197  * \brief Checks the state of this component and all its children,
198  * before starting execution.
199  *
200  * @return true if the component and all its children are ready to run,
201  * false otherwise.
202  */
203  bool PreRunCheck(GXemul* gxemul);
204 
205  /**
206  * \brief Resets the cached state of this component and all its
207  * children.
208  *
209  * For performance reasons, while an emulation is running, it is usually
210  * a good idea to cache e.g. pointers to various things. However,
211  * after pausing an emulation, and continuing again, these pointers
212  * may not be valid. FlushCachedState() should be called before
213  * Run() is called.
214  */
215  void FlushCachedState();
216 
217  /**
218  * \brief Execute one or more cycles.
219  *
220  * Note 1: A component must attempt to execute exactly the number of
221  * specified cycles.
222  *
223  * Note 2: If e.g. a breakpoint is reached, or some fatal error occurs
224  * (such as an unimplemented feature in the emulation of the component
225  * is triggered), then it is ok to return fewer than the requested
226  * number of cycles. Execution will then stop (or the breakpoint will
227  * be handled, etc).
228  *
229  * Note 3: The framework will only call this function if the component
230  * has a StateVariable named "frequency". Components that do not have
231  * any frequency do not execute anything periodically by themselves.
232  *
233  * @param gxemul A pointer to the GXemul instance.
234  * @param nrOfCycles The requested number of cycles to run.
235  * @return The number of cycles actually executed.
236  */
237  virtual int Execute(GXemul* gxemul, int nrOfCycles);
238 
239  /**
240  * \brief Returns the current frequency (in Hz) that the component
241  * runs at.
242  *
243  * @return The component's frequency in Hz.
244  */
245  virtual double GetCurrentFrequency() const;
246 
247  /**
248  * \brief Returns the component's RootComponent interface.
249  *
250  * @return A pointer to the component as a %RootComponent, or
251  * NULL if the component isn't a %RootComponent.
252  */
253  virtual RootComponent* AsRootComponent();
254 
255  /**
256  * \brief Returns the component's CPUComponent interface.
257  *
258  * @return A pointer to the component as a %CPUComponent, or
259  * NULL if the component isn't a CPU.
260  */
261  virtual CPUComponent* AsCPUComponent();
262 
263  /**
264  * \brief Returns the component's AddressDataBus interface, if any.
265  *
266  * @return A pointer to an AddressDataBus, or NULL if the
267  * component does not support that interface.
268  */
269  virtual AddressDataBus* AsAddressDataBus();
270 
271  /**
272  * \brief Sets the parent component of this component.
273  *
274  * Note: Not reference counted.
275  *
276  * @param parentComponent a pointer to the parent component.
277  */
278  void SetParent(Component* parentComponent);
279 
280  /**
281  * \brief Gets this component's parent component, if any.
282  *
283  * Note: Not reference counted.
284  *
285  * Returns NULL if there is no parent component.
286  *
287  * @return the pointer to the parent component, or NULL
288  */
289  Component* GetParent();
290  const Component* GetParent() const;
291 
292  /**
293  * \brief Retrieves a component's implemented method names.
294  *
295  * Note that a component's implementation should call its
296  * base class' GetMethodNames(vector<string>&) too. However, when
297  * methods are executed, the most specific implementation (i.e.
298  * not the base class) will get a chance first to execute the method.
299  *
300  * @param names A vector of strings, where method names
301  * should be added.
302  */
303  virtual void GetMethodNames(vector<string>& names) const;
304 
305  /**
306  * \brief Returns whether a method name may be re-executed without args.
307  *
308  * Typical examples may be a RAMComponent which has a "dump" method,
309  * or a CPUComponent which has "dump" and "unassemble" methods.
310  *
311  * Note that a component's implementation should call its
312  * base class' MethodMayBeReexecutedWithoutArgs(cosnt string&) too.
313  *
314  * @param methodName The name of the method.
315  * @return true if the method may be re-executed without arguments,
316  * false otherwise.
317  */
318  virtual bool MethodMayBeReexecutedWithoutArgs(const string& methodName) const;
319 
320  /**
321  * \brief Executes a method on the component.
322  *
323  * Note 1: The method name must be one of those returned
324  * by GetMethodNames(vector<string>&), either in the class itself
325  * or by one of the base implementations.
326  *
327  * Note 2: The base class' member function should <i>only</i> be called
328  * if this class does not handle the method.
329  *
330  * @param gxemul A reference to the GXemul instance.
331  * @param methodName The name of the method.
332  * @param arguments A vector of arguments to the method.
333  */
334  virtual void ExecuteMethod(GXemul* gxemul,
335  const string& methodName,
336  const vector<string>& arguments);
337 
338  /**
339  * \brief Generates a string representation of the path to the
340  * %Component.
341  *
342  * The path consists of "name.name...name.name" where the last name
343  * is the name of this component, and the preceding names are names
344  * of parents.
345  *
346  * If a component does not have a "name" state variable, then the
347  * class name in parentheses is used instead (which may make the path
348  * non-unique).
349  *
350  * @return A path to the component, as a string.
351  */
352  string GeneratePath() const;
353 
354  /**
355  * \brief Generates a short string representation of the path to the
356  * %Component.
357  *
358  * This function generates a string which is the shortest possible
359  * sub-path required to uniqely identify a component in the tree.
360  * (Actually, not really the shortest. For example if a component is
361  * called root.machine0.mainbus0.ram0, then the shortest string may
362  * be "ra". This function will return "ram0".)
363  *
364  * If there are components a.b.x, a.b.y, and a.c.x, then the shortest
365  * possible paths for the three components are "b.x", "y", and "c.x"
366  * respectively.
367  *
368  * @return A string which is part of the path of the component.
369  */
370  string GenerateShortestPossiblePath() const;
371 
372  /**
373  * \brief Looks up a path from this %Component,
374  * and returns a pointer to the found %Component, if any
375  *
376  * The first name in the path should match the name of this component.
377  * If so, this function moves on to the next part of the path (if there
378  * are more parts) and looks up a child with that name, and so on.
379  *
380  * Alternatively, the path may be a partial match.
381  *
382  * @param path The path to the component, consisting of names with
383  * "." (period) between names.
384  * @return A reference counted pointer to the looked up component,
385  * which is set to NULL if the path was not found.
386  */
387  const refcount_ptr<Component> LookupPath(string path) const;
388 
389  /**
390  * \brief Finds complete component paths, given a partial path.
391  *
392  * E.g. if the following components are available:<pre>
393  * root.machine0.isabus0
394  * root.machine1.pcibus0
395  * root.machine1.pcibus1
396  * root.machine2.pcibus0
397  * root.machine3.otherpci
398  * </pre>
399  *
400  * then a search for "pci" would return<pre>
401  * root.machine1.pcibus0
402  * root.machine1.pcibus1
403  * root.machine2.pcibus0
404  * </pre>
405  * (note: not otherpci)
406  *
407  * A search for machine1 would return<pre>
408  * root.machine1
409  * </pre>
410  *
411  * Multiple words separated by "." should also be possible, so
412  * "machine2.pcibus" will find "root.machine2.pcibus0", but
413  * "machine.pcibus" will <i>not</i> match anything.
414  *
415  * Searching for an empty string ("") returns a vector of <i>all</i>
416  * component paths.
417  *
418  * @param partialPath The partial path to complete.
419  * @param shortestPossible Return shortest possible paths, instead of
420  * full paths.
421  * @return A vector of possible complete paths.
422  */
423  vector<string> FindPathByPartialMatch(const string& partialPath,
424  bool shortestPossible = false) const;
425 
426  /**
427  * \brief Adds a reference to a child component.
428  *
429  * @param childComponent A reference counted pointer to the child
430  * component to add.
431  * @param insertPosition If specified, this is the position in the
432  * vector of child components where the child will be inserted.
433  * If not specified (or -1), then the child will be added to
434  * the end of the vector.
435  */
436  void AddChild(refcount_ptr<Component> childComponent,
437  size_t insertPosition = (size_t) -1);
438 
439  /**
440  * \brief Removes a reference to a child component.
441  *
442  * @param childToRemove A pointer to the child to remove.
443  * @return A zero-based index, which is the position in the vector
444  * of children where the child was. (Needed for e.g. Undo
445  * functionality.)
446  */
447  size_t RemoveChild(Component* childToRemove);
448 
449  /**
450  * \brief Gets pointers to child components.
451  *
452  * @return Reference counted pointers to child components.
453  */
454  Components& GetChildren();
455 
456  /**
457  * \brief Gets pointers to child components, as a const reference.
458  *
459  * @return Reference counted pointers to child components.
460  */
461  const Components& GetChildren() const;
462 
463  /**
464  * \brief Retrieves a component's state variable names.
465  *
466  * @param names A vector of strings, where method names
467  * should be added.
468  */
469  void GetVariableNames(vector<string>& names) const;
470 
471  /**
472  * \brief Gets a pointer to a state variable.
473  *
474  * NOTE: The returned pointer should be used immediately after the
475  * call. It will in general not be valid after e.g. an
476  * AddVariable call.
477  *
478  * @param name The variable name.
479  * @return A pointer to the variable, it the name was
480  * known; NULL otherwise.
481  */
482  StateVariable* GetVariable(const string& name);
483 
484  /**
485  * \brief Gets a pointer to a state variable.
486  *
487  * NOTE: The returned pointer should be used immediately after the
488  * call. It will in general not be valid after e.g. an
489  * AddVariable call.
490  *
491  * @param name The variable name.
492  * @return A pointer to the variable, it the name was
493  * known; NULL otherwise.
494  */
495  const StateVariable* GetVariable(const string& name) const;
496 
497  /**
498  * \brief Sets a variable to a new value.
499  *
500  * @param name The variable name.
501  * @param expression The new value.
502  * @return True if the value was set, false otherwise. (E.g. if
503  * the name was not known, or if there was a parse error
504  * when parsing the value expression.)
505  */
506  bool SetVariableValue(const string& name, const string& expression);
507 
508  /**
509  * \brief Serializes the %Component into a string stream.
510  *
511  * @param ss An ostream which the %Component will be serialized to.
512  * @param context A serialization context (used for TAB indentation).
513  */
514  void Serialize(ostream& ss, SerializationContext& context) const;
515 
516  /**
517  * \brief Deserializes a string into a component tree.
518  *
519  * @param messages A stream where errors/warnings may be reported.
520  * @param str The string to deserialize.
521  * @param pos Initial deserialization position in the string; should
522  * be 0 when invoked manually. (Used for recursion, to avoid
523  * copying.)
524  * @return If deserialization was successful, the
525  * reference counted pointer will point to a component tree;
526  * on error, it will be set to NULL
527  */
528  static refcount_ptr<Component> Deserialize(ostream& messages,
529  const string& str, size_t& pos);
530 
531  /**
532  * \brief Checks consistency by serializing and deserializing the
533  * component (including all its child components), and comparing
534  * the checksum of the original tree with the deserialized tree.
535  *
536  * @return true if the serialization/deserialization was correct,
537  * false if there was some inconsistency
538  */
539  bool CheckConsistency() const;
540 
541  /**
542  * \brief Adds this component's state, including children, to
543  * a checksum.
544  *
545  * @param checksum The checksum to add to.
546  */
547  void AddChecksum(Checksum& checksum) const;
548 
549 protected:
550  /**
551  * \brief Adds a state variable of type T to the %Component.
552  *
553  * This function is only meant to be called from the component's
554  * constructor.
555  *
556  * @param name The variable name.
557  * @param variablePointer A pointer to the variable that the name should
558  * be connected to.
559  * @return True if the state variable was added, false if the name
560  * was already in use.
561  */
562  template<class T>
563  bool AddVariable(const string& name, T* variablePointer)
564  {
565  StateVariableMap::iterator it = m_stateVariables.find(name);
566  if (it != m_stateVariables.end())
567  return false;
568 
569  m_stateVariables.insert(pair<string,StateVariable>
570  (name, StateVariable(name, variablePointer)));
571  return true;
572  }
573 
574  /**
575  * \brief Adds a custom state variable to the %Component.
576  *
577  * This function is only meant to be called from the component's
578  * constructor.
579  *
580  * @param name The variable name.
581  * @param variableHandler A pointer to the handler that knows how
582  * to serialize/deserialize the variable.
583  * @return True if the state variable was added, false if the name
584  * was already in use.
585  */
586  bool AddCustomVariable(const string& name, CustomStateVariableHandler* variableHandler)
587  {
588  StateVariableMap::iterator it = m_stateVariables.find(name);
589  if (it != m_stateVariables.end())
590  return false;
591 
592  m_stateVariables.insert(pair<string,StateVariable>
593  (name, StateVariable(name, variableHandler)));
594  return true;
595  }
596 
597  /**
598  * \brief Checks whether a write to a variable is OK.
599  *
600  * This function is called <i>after</i> the variable has been written.
601  * By returning false, the component indicates that the value which
602  * was written is invalid, and the write will be undone.
603  *
604  * An implementation should first check variables defined for the
605  * implementation class, and then call its base class' function.
606  *
607  * The implementation in the base Component class handles the variables
608  * that are defined for all components, and returns true for anything
609  * else.
610  *
611  * @param var The variable to check.
612  * @param oldValue The serialized previous value.
613  * @return true if the write was ok, false otherwise.
614  */
615  virtual bool CheckVariableWrite(StateVariable& var, const string& oldValue);
616 
617  /**
618  * \brief Resets the state variables of this component.
619  *
620  * Note 1: This function is not recursive, so children should not be
621  * traversed.
622  *
623  * Note 2: After a component's state variables have been reset, the
624  * base class' ResetState() function should also be called.
625  *
626  * The implementation of this function ususally takes the form of a
627  * number of assignment of values to member variables, and then
628  * the call to the base class' ResetState() function.
629  */
630  virtual void ResetState();
631 
632  /**
633  * \brief Checks the state of this component, before starting execution.
634  *
635  * Note 1: This function is not recursive, so children should not be
636  * traversed.
637  *
638  * Note 2: After a component's state variables have been checked, the
639  * base class' PreRunCheckForComponent(GXemul*) function should also be
640  * called.
641  *
642  * The implementation of this function may choose to print warning
643  * messages but still return true, or it can print error messages and
644  * return false.
645  *
646  * Typical examples of pre-run-check failures are:
647  * <ul>
648  * <li>collision of MemoryMappedComponent on an AddressDataBus
649  * <li>a CPUComponent that can not reach any kind of AddressDataBus
650  * </ul>
651  *
652  * @return true if the component is ready to run, false otherwise.
653  */
654  virtual bool PreRunCheckForComponent(GXemul* gxemul);
655 
656  /**
657  * \brief Resets the cached state of this component.
658  *
659  * Note 1: This function is not recursive, so children should not be
660  * traversed.
661  *
662  * Note 2: After a component's state variables have been reset, the
663  * base class' FlushCachedStateForComponent() function should also be
664  * called.
665  *
666  * The implementation of this function ususally takes the form of
667  * setting a number of pointers to NULL, and then
668  * the call to the base class' FlushCachedStateForComponent() function.
669  */
670  virtual void FlushCachedStateForComponent();
671 
672  /**
673  * \brief Returns a reference to the current GXemul instance.
674  *
675  * @return NULL if there was no currently running instance, otherwise
676  * a pointer to the currently running GXemul instance.
677  */
678  GXemul* GetRunningGXemulInstance();
679 
680  /**
681  * \brief Gets an UI reference for outputting debug messages during
682  * runtime.
683  *
684  * @return NULL if debug messages are turned off, or if there is no
685  * owning GXemul instance. Otherwise, a pointer to an UI.
686  */
687  UI* GetUI();
688 
689 private:
690  /**
691  * \brief Looks up a path from this %Component,
692  * and returns a pointer to the found %Component, if any
693  *
694  * The first name in the path should match the name of this component.
695  * If so, this function moves on to the next part of the path (if there
696  * are more parts) and looks up a child with that name, and so on.
697  *
698  * @param path The path to the component, split into separate names.
699  * This vector should contain at least 1 element.
700  * @param index The index into the path vector, where the current
701  * lookup should start. (This is to avoid copying.)
702  * @return A reference counted pointer to the looked up component,
703  * which is set to NULL if the path was not found.
704  */
705  const refcount_ptr<Component> LookupPath(const vector<string>& path,
706  size_t index) const;
707 
708  /**
709  * \brief Internal helper, which gathers a list of all component paths.
710  *
711  * @param allComponentPaths A vector which will be filled with all
712  * components' paths.
713  */
714  void AddAllComponentPaths(vector<string>& allComponentPaths) const;
715 
716  /**
717  * \brief Internal helper for LightClone.
718  *
719  * See LightClone() for details.
720  */
721  refcount_ptr<Component> LightCloneInternal() const;
722 
723  /**
724  * \brief Disallow creation of %Component objects using the
725  * default constructor.
726  */
727  Component();
728 
729 private:
730  Component* m_parentComponent;
731  Components m_childComponents;
732  string m_className;
733  string m_visibleClassName;
734  StateVariableMap m_stateVariables;
735 
736  // The following are this component's variables. Components that
737  // inherit from this class add their own instance variables.
738  string m_name; // This Component's instance name.
739  string m_template; // Set if this Component
740  // was based on a template.
741  uint64_t m_step; // Nr of executed steps.
742 };
743 
744 
745 #endif // COMPONENT_H
bool AddCustomVariable(const string &name, CustomStateVariableHandler *variableHandler)
Adds a custom state variable to the Component.
Definition: Component.h:586
bool AddVariable(const string &name, T *variablePointer)
Adds a state variable of type T to the Component.
Definition: Component.h:563
A Component which is the default root node in the configuration.
Definition: RootComponent.h:57
A checksum accumulator.
Definition: Checksum.h:47
map< string, StateVariable > StateVariableMap
Definition: StateVariable.h:41
An interface for implementing components that read/write data via an address bus. ...
The main emulator class.
Definition: GXemul.h:54
map< string, string > ComponentCreationSettings
Definition: Component.h:46
virtual ~Component()
Definition: Component.h:83
A context used during serialization of objects.
Base class for reference countable objects.
Definition: refcount_ptr.h:62
A Component is a node in the configuration tree that makes up an emulation setup. ...
Definition: Component.h:62
StateVariables make up the persistent state of Component objects.
Definition: StateVariable.h:67
A base-class for processors Component implementations.
Definition: CPUComponent.h:43
ComponentCreationSettings componentCreationSettings
Definition: Component.h:51
Base class for a User Interface.
Definition: UI.h:40
vector< refcount_ptr< Component > > Components
Definition: Component.h:43

Generated on Fri Dec 7 2018 19:52:23 for GXemul by doxygen 1.8.13