VRS - The Virtual Rendering System

version 3.3

document.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2003 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: document.h 6472 2008-08-25 13:18:27Z Tassilo_Glander $
// $Date: 2008-08-25 15:18:27 +0200 (Mon, 25 Aug 2008) $
// $Revision: 6472 $
// $State$
// $Author: Tassilo_Glander $
//
// $Log$
// Revision 1.7  2005/01/03 01:43:09  klimetschek
// - modified win32 project layout, splitted vrs.vcproj into vrs_container, vrs_core, vrs_sg, vrs_image, vrs_opengl and vrs_io
// - removed vrs.vcproj
// minor things:
// - added all glutexamples to vrs4glut.sln
// - fixed some problems in glutexamples
// - removed all project references from all VS projects (using solution wide project dependencies instead)
//
// Revision 1.6  2004/11/03 11:56:56  saar
// Class comment changed (Doxygen style)
//
// Revision 1.5  2004/10/04 06:07:22  baumann
// moved serialization of VRS::Color and VRS::Vector into VRS::SerializationManager
//
// Revision 1.4  2004/03/12 16:28:40  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.3  2004/01/29 10:40:26  wendland
// added parameter const std::string& knownType to serialize(SharedObj)
//
// Revision 1.2  2004/01/20 07:51:25  baumann
// exception ctors changed
//
// Revision 1.1  2004/01/19 17:07:21  baumann
// moved VRS::Document from vrs/ to vrs/io/
//
// Revision 1.32  2004/01/19 11:43:56  baumann
// serialization mechanism improved
//
// Revision 1.31  2004/01/19 07:28:03  baumann
// serialization mechanism improved
//
// Revision 1.30  2004/01/15 14:16:53  baumann
// serialization mechanism improved
//
// Revision 1.29  2004/01/14 07:32:32  baumann
// skipping of default values added
//
// Revision 1.28  2004/01/13 11:19:45  baumann
// added startClass() and endClass() to SerializationManager
//
// Revision 1.27  2004/01/13 09:04:29  baumann
// DocumentHandler renamed to SerializationManager
//
// Revision 1.26  2004/01/12 15:15:50  baumann
// new class VRS::DocumentHandler is now base class of class VRS::Document
//
// Revision 1.25  2003/11/07 14:19:23  kirsch
// removed leading underscore from include guards
//
// Revision 1.24  2003/09/01 08:18:14  baumann
// 64 bit data types added
//
// Revision 1.23  2003/07/02 11:32:07  kirsch
// explicitely declared std namespace where appropriate
//
// Revision 1.22  2003/06/23 09:47:42  baumann
// - new compile time switch VRS_HAS_WSTRING added
// - renamed macros VRS_HAVE_* to VRS_HAS_*
// - removed "typedef std::string String;"
// - Font uses ImageTexture2D instead of ImageTexture2DGL
//
// Revision 1.21  2003/06/23 07:05:40  baumann
// new method isVersion() added
//
// Revision 1.20  2003/02/25 22:00:46  skirsch
// correction and improvement of the comments
//
// Revision 1.19  2002/10/29 11:04:16  skirsch
// added serialization operator for wstring
//
// Revision 1.18  2002/09/14 10:42:55  baumann
// documents cann now store objects without a name
//
// Revision 1.17  2002/07/24 14:30:52  nienhaus
// serialize-method for char*
//
// Revision 1.16  2002/07/12 07:14:32  baumann
// new template function serializeEnum() added
//
// Revision 1.15  2002/07/02 15:23:48  baumann
// non-persistent containers now have the prefix NonPersistent, e.g. NonPersistentArray<T>
// persistent containers now have no prefix, e.g. Array<T>
//
// Revision 1.14  2002/03/07 08:49:49  kosta
// replaced "class VRS::String" by "typedef std::string String"
//
// Revision 1.13  2002/03/03 21:44:24  kosta
// VRS_TYPEINFO-macro rewritten
//
// Revision 1.12  2002/02/19 10:34:07  kosta
// undone all changes since 2002-02-15
//
// Revision 1.9  2002/02/14 09:37:20  kosta
// automatic serialization registration for template classes implemented
//
// Revision 1.8  2002/02/05 07:48:25  kosta
// new persistency macros:
//     VRS_SERIALIZABLE(CLASS_NAME);
//     VRS_SERIALIZABLE_ABSTRACT_CLASS(CLASS_NAME);
//     VRS_SERIALIZABLE_NO_SO_CLASS(CLASS_NAME)
//
// Revision 1.7  2002/02/04 11:54:37  kosta
// persistency rewritten (for better namespace support)
//
// Revision 1.6  2002/01/19 11:27:38  kosta
// serialization of std::string added
//
// Revision 1.5  2002/01/15 16:25:53  kosta
// macros rewritten for a better namespace support
//
// Revision 1.4  2001/11/13 16:36:30  kirsch
// changed line feed to unix style (removed control-M)
//
// Revision 1.3  2001/07/06 21:22:09  kosta
// order of include statements changed in order to avoid some nesty warnings
//
// Revision 1.2  2001/07/05 12:43:14  kersting
// added enum name and set method parameters due to enum name
//
// Revision 1.1.1.1  2001/06/08 08:09:20  kirsch
// imported alpha-version by olli 
//

#ifndef VRS_IO_DOCUMENT_H
#define VRS_IO_DOCUMENT_H

#include <vrs/config.h>
#include <vrs/id.h>
#include <vrs/exception.h>
#include <vrs/serializationmanager.h>
#include <iosfwd>
#include <string>

namespace VRS {

template<class T> class Array;
template<class T> class Iterator;
template<class T> class HashTable;
template<class T, class V> class NonPersistentDictionary;


class VRS_CORE_API Document : public SerializationManager {
public:
    Document(const std::string& creator = "unknown");
    virtual ~Document();

    const std::string& creator() const;
    const std::string& creationDate() const;

    unsigned int versionMajor() const;
    unsigned int versionMinor() const;

    bool isVersion(unsigned int major, unsigned int minor) const;

    bool addObject(SharedObj* obj);

    bool addObject(SharedObj* obj, const std::string& name);

    bool removeObject(SharedObj* obj);

    bool removeObject(const std::string& name);

    void clearObjects();

    SharedObj* object(const std::string& name) const;
    int objects() const;
    Iterator<SO<SharedObj> >* objectIterator() const;

    Iterator<SO<SharedObj> >* scanObjects();

    void writeDocument(std::ostream&);
    void writeDocument(const std::string& filename);
    std::ostream& output();



    void readDocument(std::istream&, const unsigned int &size = 0);

    void readDocument(const std::string& filename);
    std::istream& input();

    enum DocMode { Reading, Writing, Scanning, Reserved };
    VRS_SERIALIZABLE_CLASS_ENUM(DocMode);
    DocMode mode () const;

    // implement the interface of base class SerializationManager
    virtual bool isReading() const;
    virtual bool skipDefaultValues() const;
    virtual void startClass(const std::string& classID, const std::string& attributeName);
    virtual void endClass(  const std::string& classID, const std::string& attributeName);
    virtual void classVersion(UINT8& version);
    virtual void serialize(const std::string& attributeName, bool&         attributeValue);
    virtual void serialize(const std::string& attributeName, UINT8&        attributeValue);
    virtual void serialize(const std::string& attributeName, INT8&         attributeValue);
    virtual void serialize(const std::string& attributeName, UINT16&       attributeValue);
    virtual void serialize(const std::string& attributeName, INT16&        attributeValue);
    virtual void serialize(const std::string& attributeName, UINT32&       attributeValue);
    virtual void serialize(const std::string& attributeName, INT32&        attributeValue);
    virtual void serialize(const std::string& attributeName, UINT64&       attributeValue);
    virtual void serialize(const std::string& attributeName, INT64&        attributeValue);
    virtual void serialize(const std::string& attributeName, float&        attributeValue);
    virtual void serialize(const std::string& attributeName, double&       attributeValue);
    virtual void serialize(const std::string& attributeName, std::string&  attributeValue);
    virtual void serialize(const std::string& attributeName, ID&           attributeValue);

    virtual void serialize(const std::string& attributeName, Color&        attributeValue);
    virtual void serialize(const std::string& attributeName, Vector&       attributeValue);

    virtual void serialize(const std::string& attributeName, SharedObj*&   attributeValue, 
                                                                                                                         const std::string& knownType);
#ifdef VRS_HAS_WSTRING
    virtual void serialize(const std::string& attributeName, std::wstring& attributeValue);
#endif // VRS_HAS_WSTRING
    virtual void serialize(const std::string& attributeName, void* pointer, unsigned int bytes);

    VRS_TYPEINFO(Document, SerializationManager);

private:
    // meta information
    std::string creator_;
    std::string date_;
    unsigned int major_;
    unsigned int minor_;

    // objects directly contained in the document
    SO<Array<SO<SharedObj> > > objects_;
    int mode_;

    // for writing
    SO<NonPersistentDictionary<SharedObj*, unsigned int> > writtenObjects_;
    std::ostream* out_;

    // for reading
    SO<Array<SO<SharedObj> > > readObjects_;
    std::istream* in_;
    bool needSwap_;

    // scanning
    SO<HashTable<SO<SharedObj> > > scannedObjects_;
}; // class Document

class DocFormatError : public Exception {
public:
    DocFormatError(const std::string& description) :
        Exception("", __FILE__, __LINE__, description) { }
};

class DocStreamError : public Exception {
public:
    DocStreamError(const std::string& description) :
        Exception("", __FILE__, __LINE__, description) { }
};

} // namespace VRS

#endif // VRS_IO_DOCUMENT_H

---

Generated on Wed May 23 06:00:12 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact