[GME-commit] GMESRC/GME/Core CoreXmlFile.cpp,NONE,1.1 CoreXmlFile.h,NONE,1.1 CoreXmlFile.rgs,NONE,1.1

[gme-commit at list.isis.vanderbilt.edu]

Update of /var/lib/gme/GMESRC/GME/Core
In directory braindrain:/tmp/cvs-serv19383

Added Files:
	CoreXmlFile.cpp CoreXmlFile.h CoreXmlFile.rgs 
Log Message:
no message

CVS User: bogyom

--- NEW FILE: CoreXmlFile.cpp ---

#include "stdafx.h"
#include <io.h>
#include <stdlib.h>
#include <util/PlatformUtils.hpp>
#include <dom/DOM_NamedNodeMap.hpp>
#include "CoreXmlFile.h"
#include "CommonCollection.h"

void bin2string( const unsigned char * bytes, int len, string& str )
{
    char hex[3];
    str.clear();
    for( int i=0; i<len; ++i )
    {
        sprintf( hex, "%02x", bytes[i] );
        str += hex;
    }
}
[...1266 lines suppressed...]
	vector<xmlobjects_iterator>::const_iterator e = a.end();
	while( i != e )
	{
		idpairs.push_back( (*i)->first );

		++i;
	}

	CopyTo(idpairs, p);
}

template<>
void XmlAttr<VALTYPE_COLLECTION>::ToString(string& str) const
{
}
    
template<>
void XmlAttr<VALTYPE_COLLECTION>::FromString(const char * str)
{
}

--- NEW FILE: CoreXmlFile.h ---

#ifndef MGA_COREXMLFILE_H
#define MGA_COREXMLFILE_H

#include <fstream.h>
#include <slist>
#include <map>
#include <hash_map>
#include <parsers/DOMParser.hpp>
#include "..\Mga\MgaGeneric.h"

class CCoreXmlFile;

const metaobjidpair_type null_objid = {METAID_NONE, METAID_NONE};
const GUID null_guid = {0,0,0,{0,0,0,0,0,0,0,0}};

void bin2string( const unsigned char * bytes, int len, string& str );
void string2bin( const char * str, unsigned char * bytes );

// --------------------------- XmlAttr

class XmlAttrBase
{
public:
    attrid_type attrid;

	                     XmlAttrBase () : attrid(ATTRID_NONE) { }
	virtual             ~XmlAttrBase () { }

	static XmlAttrBase * Create      (valtype_type valtype);

	virtual valtype_type GetValType  () const NOTHROW = 0;
	virtual void         Set         (CCoreXmlFile *binfile, VARIANT p) = 0;
	virtual void         Get         (CCoreXmlFile *binfile, VARIANT *p) const = 0;
    virtual void         ToString    (string& str) const = 0;
    virtual void         FromString  (const char * str) = 0;
};

typedef slist<XmlAttrBase*>     xmlattrs_type;
typedef xmlattrs_type::iterator xmlattrs_iterator;

template<int VALTYPE>
class XmlAttr;

// --------------------------- XmlObject

class XmlObject
{
public:
    xmlattrs_type      xmlattrs;
	bool               deleted;
    metaobjidpair_type parent;
    GUID               guid;

                    XmlObject           ();
	               ~XmlObject           ();
	
	void            CreateAttributes    (ICoreMetaObject *metaobject);
	void            DestroyAttributes   ();
    XmlAttrBase *   FindAttribute       (attrid_type attrid);
};

typedef hash_map<metaobjidpair_type, XmlObject,
	metaobjidpair_hashfunc, metaobjidpair_equalkey> xmlobjects_type;
typedef xmlobjects_type::iterator                   xmlobjects_iterator;
typedef map<metaid_type,attrid_type>                parentmap_type;

extern xmlobjects_iterator no_xmlobject;

// --------------------------- CCoreXmlFile

class ATL_NO_VTABLE CCoreXmlFile : 
	public CComObjectRootEx<CComSingleThreadModel>,
	public IDispatchImpl<ICoreStorage, &IID_ICoreStorage, &LIBID_CORELib>,
	public ISupportErrorInfoImpl<&IID_ICoreStorage>,
	public CComCoClass<CCoreXmlFile, &CLSID_CoreBinFile>
{
public:
	CCoreXmlFile();
	~CCoreXmlFile();

BEGIN_COM_MAP(CCoreXmlFile)
	COM_INTERFACE_ENTRY(ICoreStorage)
	COM_INTERFACE_ENTRY(IDispatch)
	COM_INTERFACE_ENTRY(ISupportErrorInfo)
END_COM_MAP()

DECLARE_REGISTRY_RESOURCEID(IDR_COREXMLFILE)

// ------- MetaProject

public:
	CComObjPtr<ICoreMetaProject> metaproject;
	bindata metaprojectid;

	STDMETHODIMP get_MetaProject(ICoreMetaProject **p);
	STDMETHODIMP put_MetaProject(ICoreMetaProject *p);

	void OpenMetaProject();
	void CloseMetaProject() NOTHROW;

// ------- MetaObject

public:
	CComObjPtr<ICoreMetaObject> metaobject;
	metaid_type metaid;

	STDMETHODIMP get_MetaObject(ICoreMetaObject **p);
	STDMETHODIMP put_MetaObject(ICoreMetaObject *p);

	STDMETHODIMP get_MetaID(metaid_type *p);
	STDMETHODIMP put_MetaID(metaid_type p);

	void OpenMetaObject();
	void CloseMetaObject() NOTHROW;

// ------- MetaAttribute

public:
	CComObjPtr<ICoreMetaAttribute> metaattribute;
	attrid_type attrid;

	STDMETHODIMP get_MetaAttribute(ICoreMetaAttribute **p);
	STDMETHODIMP put_MetaAttribute(ICoreMetaAttribute *p);

	STDMETHODIMP get_AttrID(attrid_type *p);
	STDMETHODIMP put_AttrID(attrid_type p);

	void OpenMetaAttribute();
	void CloseMetaAttribute() NOTHROW;

// ------- Attribute

public:
	typedef hash_map< XmlAttrBase*, CComVariant, 
		ptr_hashfunc<XmlAttrBase>, ptr_equalkey<XmlAttrBase> > undos_type;
	typedef undos_type::iterator undos_iterator;

	undos_type undos;

	STDMETHODIMP get_AttributeValue(VARIANT *p);
	STDMETHODIMP put_AttributeValue(VARIANT p);

// ------- Object

public:
	xmlobjects_type     objects;
	xmlobjects_iterator opened_object;

	//typedef hash_map<metaid_type, objid_type> maxobjids_type;
	//typedef maxobjids_type::iterator maxobjids_iterator;

	//maxobjids_type maxobjids;
    int nextobjid;

	slist<xmlobjects_iterator> deleted_objects;
	slist<xmlobjects_iterator> created_objects;

	struct resolve_type
	{
		xmlobjects_iterator obj;
		attrid_type attrid;
		metaobjidpair_type idpair;
	};

	typedef slist<resolve_type> resolvelist_type;
	resolvelist_type resolvelist;

	void InitObjID();

public:
	STDMETHODIMP OpenObject(objid_type objid);
	STDMETHODIMP CreateObject(objid_type *objid);
	STDMETHODIMP CloseObject() NOTHROW;

	STDMETHODIMP DeleteObject();
	STDMETHODIMP LockObject();
    
// ------- Project

public:
	string filename;    // holds the root file name without extension
    string filePath;    // holds the path
	bool   read_only;
	bool   intrans;
	bool   modified;

    void FillFileNameAndPath(BSTR connection); 

	bool IsOpened() const { return !filename.empty(); }
	bool InTransaction() const { return intrans; }

	void CancelProject() NOTHROW;
	void SaveProject();
	void LoadProject();

public:
	STDMETHODIMP OpenProject(BSTR connection, VARIANT_BOOL *ro_mode);
	STDMETHODIMP CreateProject(BSTR connection);
	STDMETHODIMP CloseProject( VARIANT_BOOL abort = VARIANT_FALSE) NOTHROW;
	STDMETHODIMP SaveProject(BSTR connection, VARIANT_BOOL keepoldname);
	STDMETHODIMP DeleteProject() { return E_NOTIMPL; }

	STDMETHODIMP BeginTransaction();
	STDMETHODIMP CommitTransaction();
	STDMETHODIMP AbortTransaction();

	STDMETHODIMP get_StorageType(long *p);

protected:
    parentmap_type  parentmap;

    void ReadObject         ( DOM_Element * element );
    void WriteObject        ( FILE * file, string indent, xmlobjects_iterator it );
    void FillParentMap      ();
    void SetParents         ();
    void SetPointers        ();
    void SetCollections     ();
};

// --------------------------- XmlAttr<VALTYPE_LONG>

template<>
class XmlAttr<VALTYPE_LONG> : public XmlAttrBase
{
public:
	XmlAttr() : a(0) { }

	long a;

	virtual valtype_type GetValType() const NOTHROW { return VALTYPE_LONG; }
	virtual void Set(CCoreXmlFile *binfile, VARIANT p)
	    { ASSERT( binfile != NULL ); binfile->modified = true; CopyTo(p, a); }

	virtual void Get         (CCoreXmlFile *binfile, VARIANT *p) const { CopyTo(a, p); }
    virtual void ToString    (string& str) const;
    virtual void FromString  (const char * str);
};

// --------------------------- XmlAttr<VALTYPE_REAL>

template<>
class XmlAttr<VALTYPE_REAL> : public XmlAttrBase
{
public:
	XmlAttr() : a(0) { }

	double a;

	virtual valtype_type GetValType() const NOTHROW { return VALTYPE_REAL; }
	virtual void Set(CCoreXmlFile *binfile, VARIANT p)
	{ ASSERT( binfile != NULL ); binfile->modified = true; CopyTo(p, a); }

	virtual void Get         (CCoreXmlFile *binfile, VARIANT *p) const { CopyTo(a, p); }
    virtual void ToString    (string& str) const;
    virtual void FromString  (const char * str);
};

// --------------------------- XmlAttr<VALTYPE_STRING>

template<>
class XmlAttr<VALTYPE_STRING> : public XmlAttrBase
{
public:
	CComBstrObj a;

	virtual valtype_type GetValType() const NOTHROW { return VALTYPE_STRING; }
	virtual void Set(CCoreXmlFile *binfile, VARIANT p)
	{ ASSERT( binfile != NULL ); binfile->modified = true; CopyTo(p, a); }

	virtual void Get         (CCoreXmlFile *binfile, VARIANT *p) const { CopyTo(a, p); }
    virtual void ToString    (string& str) const { CopyTo(a, str); }
    virtual void FromString  (const char * str)  { CopyTo(str, a); }
};

// --------------------------- XmlAttr<VALTYPE_BINARY>

template<>
class XmlAttr<VALTYPE_BINARY> : public XmlAttrBase
{
public:
	bindata a;

	virtual valtype_type GetValType() const NOTHROW { return VALTYPE_BINARY; }
	virtual void Set(CCoreXmlFile *binfile, VARIANT p)
	{ ASSERT( binfile != NULL ); binfile->modified = true; CopyTo(p, a); }

	virtual void Get         (CCoreXmlFile *binfile, VARIANT *p) const { CopyTo(a, p); }
    virtual void ToString    (string& str) const;
    virtual void FromString  (const char * str);
};

// --------------------------- XmlAttr<VALTYPE_LOCK>

template<>
class XmlAttr<VALTYPE_LOCK> : public XmlAttrBase
{
public:
	XmlAttr() : a(0) { }

	lockval_type a;

	virtual valtype_type GetValType() const NOTHROW { return VALTYPE_LOCK; }
	virtual void Set         (CCoreXmlFile *binfile, VARIANT p) { CopyTo(p, a); }
	virtual void Get         (CCoreXmlFile *binfile, VARIANT *p) const { CopyTo(a, p); }
    virtual void ToString    (string& str) const {}         // TODO
    virtual void FromString  (const char * str) { a = 0; }  // TODO
};

// --------------------------- XmlAttr<VALTYPE_POINTER>

template<>
class XmlAttr<VALTYPE_POINTER> : public XmlAttrBase
{
public:
	XmlAttr() : a(no_xmlobject) { }

	xmlobjects_iterator a;
    GUID                refered_objid;

	virtual valtype_type GetValType() const NOTHROW { return VALTYPE_POINTER; }
	void Set(CCoreXmlFile *binfile, xmlobjects_iterator a);
	virtual void Set         (CCoreXmlFile *binfile, VARIANT p);
	virtual void Get         (CCoreXmlFile *binfile, VARIANT *p) const;
    virtual void ToString    (string& str) const;
    virtual void FromString  (const char * str);
};

// --------------------------- XmlAttr<VALTYPE_COLLECTION>

template<>
class XmlAttr<VALTYPE_COLLECTION> : public XmlAttrBase
{
public:
	vector<xmlobjects_iterator> a;

	virtual valtype_type GetValType() const NOTHROW { return VALTYPE_COLLECTION; }
	virtual void Set         (CCoreXmlFile *binfile, VARIANT p) { ASSERT(false); }
	virtual void Get         (CCoreXmlFile *binfile, VARIANT *p) const;
    virtual void ToString    (string& str) const;
    virtual void FromString  (const char * str);
};

#endif//MGA_COREXMLFILE_H

--- NEW FILE: CoreXmlFile.rgs ---
HKCR
{
	Mga.CoreXmlFile.1 = s 'CoreXmlFile Class'
	{
		CLSID = s '{7281C07A-3E09-11D3-B2F7-715004D38590}'
	}
	Mga.CoreXmlFile = s 'CoreXmlFile Class'
	{
		CLSID = s '{7281C07A-3E09-11D3-B2F7-715004D38590}'
		CurVer = s 'Mga.CoreXmlFile.1'
	}
	NoRemove CLSID
	{
		ForceRemove {7281C07A-3E09-11D3-B2F7-715004D38590} = s 'CoreXmlFile Class'
		{
			ProgID = s 'Mga.CoreXmlFile.1'
			VersionIndependentProgID = s 'Mga.CoreXmlFile'
			ForceRemove 'Programmable'
			InprocServer32 = s '%MODULE%'
			{
				val ThreadingModel = s 'Apartment'
			}
			'TypeLib' = s '{9E9AAACF-28B8-11D3-B36C-0060082DF884}'
		}
	}
}