source: cpp/frams/param/multiparamload.h @ 413

Last change on this file since 413 was 382, checked in by sz, 9 years ago

Moving frams/virtfile to common/virtfile:

  • file references updated (includes, makefile)
  • common/virtfile can no longer use the Framsticks specific SString (using std::string instead)
  • Property svn:eol-style set to native
File size: 6.6 KB
1// This file is a part of Framsticks SDK.
2// Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
3// See LICENSE.txt for details.
8#include <stdio.h>
9#include "param.h"
10#include <common/virtfile/virtfile.h>
11#include <frams/util/extvalue.h>
13/** This is the general "framsticks-format" file parser for loading multiple objects.
15        The loader can be configured to recognize multiple object types from object headers
16    and automatically call ParamInterface::load for the matching class.
18    Your code should repeatedly call MultiParamLoader::go() method and check the status after each call, until the end of file.
19    The loader pauses before and/or after each object giving you a chance to perform your application-specific actions (see MultiParamLoader::breakOn()).
20    If your application does not require any special actions, then the simple MultiParamLoader:run() can be used.
21    The word "record" (and "record type") used in this description refer to the textual form of a serialized object - this is to avoid confusion with 'live' objects passed to the loader methods. "Record type" can be the same as the class name, but it does not have to be the same. For example, the most common record type for storing the Genotype object is called "org" (think: organism) instead of "Genotype".
23    Typical usage scenarios:
24    1. Loading a file that contains at most one object of any given class:
25    - declare the object class(es) - MultiParamLoader::addClass()
26    - call MultiParamLoader::run()
27    - and that's all, the records from the file will be loaded into the corresponding objects
29    2. Loading multiple objects and adding them to a list (see loadtest.cpp for a sample code that demonstrates this scenario)
30    - declare the object class giving the empty "template" object - MultiParamLoader::addClass()
31    - set breakOn(AfterObject)
32    - call MultiParamLoader::go() in a loop
33    - the returned status will be equal to AfterObject each time an object is loaded. One can detect this condition and create the real object from our template object
34    (alternatively, one could breakOn(BeforeObject) and use MultiParamLoader::loadObjectNow(ParamInterface*) to load the incoming object into a newly created object).   
35 */
36class MultiParamLoader
38VirtFILE *file;
39SListTempl<VirtFILE*> filestack;
40char ownfile;
41PtrListTempl<ExtObject*> objects;
42int status;
43SString lasterror, lastcomment, lastunknown;
44ExtObject lastobject;
45int breakcond;
46Param emptyparam;
47bool aborting;
48int linenum;
50void init();
52int maybeBreak(int cond)
53{ status=cond; return breakcond & cond; }
55VirtFILE* popstack();
56void clearstack();
58  public:
59MultiParamLoader() {init();}
60MultiParamLoader(VirtFILE *f) {init(); load(f);}
61MultiParamLoader(const char* filename) {init(); load(filename);}
63~MultiParamLoader() {abort();clearObjects();}
65void reset();
67void load(); //< use previously opened file
68void load(VirtFILE *f);
69void load(const char* filename);
71/** Register the object class. Class names will be matched with object headers ("xxx:" in the input file).
72    Used with breakOn(BeforeObject) and/or breakOn(AfterObject).
73    Note that registered classes will only work when the record name matches the class name, otherwise breakOn(BeforeUnknown) must be used and then getClassName() to check for the expected record.
74 */
75void addObject(ParamInterface *pi) {objects+=new ExtObject(pi);}
76void removeObject(ParamInterface *pi) {removeObject(ExtObject(pi));}
77void addObject(const ExtObject &o) {objects+=new ExtObject(o);}
78void removeObject(const ExtObject &o);
79int findObject(const ExtObject &o);
80void clearObjects();
82/** To be used in the main loop: while(event=loader.go()) { ... }
83    loader.go() will return on specified events (@see breakOn(), noBreakOn()),
84    then you can handle the event and resume loading.
85 */
86virtual int go();
87/** same value as 'go()' */
88int getStatus() {return status;}
89int finished() {return (status==Finished);}
91VirtFILE *getFile() {return file;}
93/** Abort immediately and close the file if needed */
94void abort();
95/** @param conditions can be combined bitwise, eg. MultiParamLoader::BeforeObject |  MultiParamLoader::OnComment
96    @see BreakConfitions
98void breakOn(int conditions) {breakcond|=conditions;}
99void noBreakOn(int conditions) {breakcond&=~conditions;}
101   These constants are used as arguments in breakOn(), and as status values from go() and getStatus().
102   The user code can define some classes for automatic recognition (using addClass()); such records can be read without performing any additional actions.
104   - BeforeObject: found an object with recognized classname (addClass()). Application code can choose to skip the incoming record (skipObject()), redirect the incoming data into a different object (loadObjectNow(ParamInterface*)), or do nothing for default behavior (loading into previously registered object).
106   - AfterObject: the object was loaded into the registered class interface (addClass()). This is to allow for additional actions after loading the object (e.g. data validation).
108   - BeforeUnknown: unknown (not registered) object header detected. Like in BeforeObject, the application can skipObject() or loadObjectNow().
110@see getClass(), GetClassName()
111 */
112enum BreakConditions { Finished=0, BeforeObject=1, AfterObject=2,
113                       BeforeUnknown=4, OnComment=8, OnError=16, Loading=32 };
115/** Can be used BeforeObject and AfterObject */
116ExtObject &getObject() {return lastobject;}
117/** Can be used BeforeUnknown, BeforeObject, AfterObject */
118const SString& getObjectName() {return lastunknown;}
119void setObjectName(SString n) {lastunknown=n;}
120/** Unknown object will be loaded if you set its class BeforeUnknown */
121void setObject(ParamInterface *pi) {lastobject=ExtObject(pi);}
122void setObject(const ExtObject& o) {lastobject=o;}
123/** Can be used OnComment */
124const SString& getComment() {return lastcomment;}
125/** Can be used OnError */
126const SString& getError() {return lasterror;}
127/** Can be used BeforeObject and BeforeUnknown */
128int loadObjectNow(ParamInterface *pi,bool warn_unknown_fields=true) {return loadObjectNow(ExtObject(pi),warn_unknown_fields);}
129int loadObjectNow(const ExtObject &o,bool warn_unknown_fields=true);
130/** Can be used BeforeObject */
131int loadObjectNow() {return loadObjectNow(getObject());}
132/** Can be used BeforeObject and BeforeUnknown.
133    Object data will not be loaded. */
134int skipObject() {return loadObjectNow(&emptyparam,false);}
135/** @return 1 if no errors */
136int run();
138void includeFile(SString& filename);
139bool returnFromIncluded();
140bool alreadyIncluded(const char* filename);
Note: See TracBrowser for help on using the repository browser.