Subversion Repositories DevTools

//---------------------------------------------------------------------------

#include <vcl.h>
#include <IniFiles.hpp> // Pascal unit
#pragma hdrstop

#include "TXMLSchema.h"
#include "XMLSchemaHandles.h"
#include "XMLSchemaProxyDatatypes.h"

#include "ISchemaElement.h"
#include "ISchemaValidationObserver.h"

#include "IXmlSchemaWrapperFactory.h"
#include "IXmlSchemaWrapperHandle.h"
#include "IXmlSchemaWrapperQualification.h"
#include "IXmlSchemaWrapperSchema.h"
#include "IXmlSchemaWrapperStream.h"
#include "IXmlSchemaWrapperString.h"
#include "IXmlSchemaWrapperStringCollection.h"

using namespace XMLSchema;

#pragma package(smart_init)

class nullValidationObserver : public virtual ISchemaValidationObserver
{
public:
        virtual void validationFailure( const XMLSchema::ISchemaElement & schemaElement,
                                                                        const char *constraint,
                                                                        const char *message )
        {
        }

        virtual void validationSuccess( const XMLSchema::ISchemaElement& schemaElement,
                                                                        const char *constraint,
                                                                        const char *message )
        {
        }
};


//---------------------------------------------------------------------------
// ValidCtrCheck is used to assure that the components created do not have
// any pure virtual functions.
//

static inline void ValidCtrCheck(TXMLSchema *)
{
        new TXMLSchema(NULL);
}
//---------------------------------------------------------------------------
__fastcall TXMLSchema::TXMLSchema(TComponent* Owner)
                : TComponent(Owner),
                  m_xmlSchemaWrapper( 0 ),
                  m_getXmlSchemaWrapperFactory( 0 ),
                  m_xmlSchemaWrapperFactory( 0 ),
                  m_xmlSchema( 0 )
{
        setProfile( "XMLSchema.ini" );
        readProfile();
}
//---------------------------------------------------------------------------
namespace Xmlschema
{
        void __fastcall PACKAGE Register()
        {
        TComponentClass classes[1] = {__classid(TXMLSchema)};
        RegisterComponents("XML Schema", classes, 0);
    }
}
//------------------------------------------------------------------------------


//------------------------------------------------------------------------------
void __fastcall TXMLSchema::setProfile( const AnsiString & profile )
{
        m_profile = profile;
}


//------------------------------------------------------------------------------
AnsiString & __fastcall TXMLSchema::prependMassConfig( AnsiString & string, const AnsiString & filename )
{
        // any absolute path characters at start of filename implies we ignore MASS_CONFIG
        switch ( filename[ 1 ] )
        {
                case '.':
                case '/':
                case '\\':
                case 0:         // save checking length == 0 for next test
                        return ( string = filename );
        }

        // check if drive letter at start of filename
        if ( filename.Length() >= 3
                        && isalpha( filename[ 1 ] ) != 0                        // a-z or A-Z
                        && filename[ 2 ] == ':'                                         // :
                        && strchr( "/\\", filename[ 3 ] ) != 0 )        // / or \\
        {
                return ( string = filename );
        }

        char path[ 1024 ];
        if ( GetEnvironmentVariable( "CONFIGPATH", path, sizeof( path ) ) )
        {
                string = path;
        }
        else
        {
                string = "";
        }

        // make sure we have the path delimiter
        if ( !string.IsEmpty() &&
                 strchr( "/\\", string[ string.Length() ] ) == 0 )
        {
                string += "\\";
        }
        string += filename;
        
        return ( string );
}


//------------------------------------------------------------------------------
void __fastcall TXMLSchema::readProfile()
{
        TIniFile * profile = 0;
        try
        {
                AnsiString file;

                profile = new TIniFile( prependMassConfig( file, m_profile ) );

                m_xmlSchemaWrapperLibrary = profile->ReadString( "Init", "Wrapper", "XmlSchemaWrapperD.dll" );

                if ( m_xmlSchemaWrapperLibrary.IsEmpty() )
                {
                        Application->MessageBox(
                                "Attribute \"Wrapper\" in section \"Init\" is empty.  Cannot load XML Schema Wrapper.",
                                "TXMLSchema",
                                MB_OK );
                }
        }
        __finally
        {
                delete profile;
                profile = 0;
        }
}


//------------------------------------------------------------------------------
void __fastcall TXMLSchema::SetActive(bool Value)
{
        if ( Value == false )
        {
                m_active = false;

                if ( m_xmlSchemaWrapperFactory )
                {
                        if ( m_xmlSchema )
                        {
                                m_xmlSchema->close();

                                m_xmlSchemaWrapperFactory->destroySchema( *m_xmlSchema );
                                m_xmlSchema = 0;
                        }

                        m_xmlSchemaWrapperFactory->stop();
                        m_xmlSchemaWrapperFactory = 0;
                }
                m_getXmlSchemaWrapperFactory = 0;
                if ( m_xmlSchemaWrapper )
                {
                        ::FreeLibrary( m_xmlSchemaWrapper );
                        m_xmlSchemaWrapper = 0;
                }
        }
        else
        {
                if ( !m_xmlSchemaWrapperLibrary.IsEmpty() )
                {
                        m_xmlSchemaWrapper = ::LoadLibrary( m_xmlSchemaWrapperLibrary.c_str() );
                        if ( m_xmlSchemaWrapper )
                        {
                                m_getXmlSchemaWrapperFactory = ( getXmlSchemaWrapperFactory_t )::GetProcAddress( m_xmlSchemaWrapper, "getXmlSchemaWrapperFactory" );
                                if ( m_getXmlSchemaWrapperFactory )
                                {
                                        m_xmlSchemaWrapperFactory = &m_getXmlSchemaWrapperFactory();
                                        if ( m_xmlSchemaWrapperFactory )
                                        {
                                                if ( m_xmlSchemaWrapperFactory->start( m_profile.c_str() ) )
                                                {
                                                        m_xmlSchema = &m_xmlSchemaWrapperFactory->createSchema();
                                                        m_xmlSchema->open();

                                                        m_moduleName    = m_xmlSchema->getModuleName();
                                                        m_moduleVersion = m_xmlSchema->getModuleVersion();
                                                }
                                        }
                                }
                        }
                }
                else
                {
                        Application->MessageBox(
                                "Attribute \"Wrapper\" in section \"Init\" is empty.  Cannot load XML Schema Wrapper.",
                                "TXMLSchema",
                                MB_OK );
                }
    }
}

//------------------------------------------------------------------------------

bool __fastcall TXMLSchema::Refresh()
{
        SetActive(false);

    SetActive(true);

        return true;
}

//------------------------------------------------------------------------------

bool __fastcall TXMLSchema::GetSchemas(std::vector<std::string> &schemas)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperStringCollection * collection = 0;

                try
                {
                        collection = &m_xmlSchemaWrapperFactory->createStringCollection();
                        if ( m_xmlSchema->getSchemas( *collection ) )
                        {
                                schemas.clear();
                                const unsigned int size = collection->size();
                                for ( unsigned int position = 0; position < size; ++position )
                                {
                                        schemas.push_back( collection->operator[]( position ) );
                                }
                                return ( true );
                        }
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyStringCollection( *collection );
                        collection = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::GetAttributes(const std::string& handle, std::vector<std::string> &attributes, bool specificationOnly)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperStringCollection * collection = 0;

                try
                {
                        collection = &m_xmlSchemaWrapperFactory->createStringCollection();
                        if ( m_xmlSchema->getAttributes( handle.c_str(), *collection, specificationOnly ) )
                        {
                                attributes.clear();
                                const unsigned int size = collection->size();
                                for ( unsigned int position = 0; position < size; ++position )
                                {
                                        attributes.push_back( collection->operator[]( position ) );
                                }
                                return ( true );
                        }
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyStringCollection( *collection );
                        collection = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::GetAttributeProperty(const std::string &handle, const std::string &property_name, std::string &value)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperString * attributeValue = 0;

                try
                {
                        attributeValue = &m_xmlSchemaWrapperFactory->createString();
                        if ( m_xmlSchema->getAttributeProperty( handle.c_str(), "", property_name.c_str(), *attributeValue ) )
                        {
                                value = attributeValue->c_str();
                                return ( true );
                        }
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyString( *attributeValue );
                        attributeValue = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::Create (const char *structure_name, unsigned short version, std::string &handle, const char *qualifier)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperHandle * wrapperHandle = 0;

                try
                {
                        wrapperHandle = &m_xmlSchemaWrapperFactory->createHandle();
                        if ( m_xmlSchema->createStructure( structure_name, version, *wrapperHandle, qualifier ) )
                        {
                                handle = wrapperHandle->c_str();
                                return ( true );
                        }
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyHandle( *wrapperHandle );
                        wrapperHandle = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::Create(const char *schema, const char *structure_name, unsigned short version, std::string &handle, const char *qualifier)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperHandle * wrapperHandle = 0;

                try
                {
                        wrapperHandle = &m_xmlSchemaWrapperFactory->createHandle();
                        if ( m_xmlSchema->createStructure( structure_name, version, *wrapperHandle, qualifier ) )
                        {
                                handle = wrapperHandle->c_str();
                                return ( true );
                        }
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyHandle( *wrapperHandle );
                        wrapperHandle = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::Destroy(std::string& handle)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->destroyStructure( handle.c_str() ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::Copy (const std::string &src_handle, const std::string &dest_handle, const XMLSchema::XMLSchemaCopyArgs &copyargs)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->copyStructure(
                        dest_handle.c_str(),
                        src_handle.c_str(),
                        copyargs.searchByName,
                        copyargs.searchByTag,
                        copyargs.errorOnFindFailure ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::Deserialise(const std::string& handle, const std::string& streamtype, const std::string& stream_args, int &required_alignment, const char *buffer, unsigned int bufsize, XMLSchema::StreamCallback callbackfn)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperStream * stream = 0;

                try
                {
                        if ( streamtype == "XDR" )
                        {
                                stream = &m_xmlSchemaWrapperFactory->createXdrStream();
                        }
                        else if ( streamtype == "XML" )
                        {
                                stream = &m_xmlSchemaWrapperFactory->createXmlStream();
                        }
                        else
                        {
                                stream = &m_xmlSchemaWrapperFactory->createBinaryStream();
                        }

                        stream->putData( buffer, bufsize );
                        if ( callbackfn )
                        {
                                stream->setCallback( callbackfn );
                        }
                        if ( !stream_args.empty() )
                        {
                                stream->setArguments( stream_args.c_str() );
                        }

                        return ( m_xmlSchema->deserialise(
                                handle.c_str(),
                                *stream,
                                required_alignment ) );
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyStream( *stream );
                        stream = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::Serialise (const std::string &handle, const std::string& streamtype, const std::string& stream_args, void *&stream, unsigned int& stream_size, XMLSchema::IXmlSchemaWrapperQualification * qualifier, const char *serialise_qualifier, unsigned char required_alignment)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperStream * wrapperStream = 0;

                try
                {
                        if ( streamtype == "XDR" )
                        {
                                wrapperStream = &m_xmlSchemaWrapperFactory->createXdrStream();
                        }
                        else if ( streamtype == "XML" )
                        {
                                wrapperStream = &m_xmlSchemaWrapperFactory->createXmlStream();
                        }
                        else
                        {
                                wrapperStream = &m_xmlSchemaWrapperFactory->createBinaryStream();
                        }

                        if ( !stream_args.empty() )
                        {
                                wrapperStream->setArguments( stream_args.c_str() );
                        }

                        const bool serialised = m_xmlSchema->serialise(
                                handle.c_str(),
                                *wrapperStream,
                                qualifier,
                                serialise_qualifier,
                                required_alignment );

                        void *                  buffer = 0;
                        unsigned int    length = 0;

                        if ( wrapperStream->getData( buffer, length ) )
                        {
                                stream_size = length;
                                stream = malloc( stream_size );
                                memcpy( stream, buffer, stream_size );
                        }
                        else
                        {
                                stream_size = 0;
                                stream = 0;
                        }

                        return ( serialised );
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyStream( *wrapperStream );
                        wrapperStream = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::SetUDTArgs(const char *udtName, int argc, const char** argv)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->setUdtArguments( udtName, argc, argv ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::GetAttributeValue(const std::string &handle, const std::string& attribute_path, std::string &value)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperString * attributeValue = 0;

                try
                {
                        attributeValue = &m_xmlSchemaWrapperFactory->createString();
                        if ( m_xmlSchema->getAttributeString( handle.c_str(), attribute_path.c_str(), *attributeValue ) )
                        {
                                value = attributeValue->c_str();
                                return ( true );
                        }
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyString( *attributeValue );
                        attributeValue = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::GetAttributeValue(const std::string &handle, const std::string& attribute_path, int &value)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->getAttributeInteger32( handle.c_str(), attribute_path.c_str(), value ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::GetAttributeValue(const std::string &handle, const std::string& attribute_path, AnsiString &value)
{
        std::string string_value;

        bool result = GetAttributeValue(handle, attribute_path, string_value);

    if (result)
    {
        value = string_value.c_str();
    }

    return result;
}

bool __fastcall TXMLSchema::SetAttributeValue (const std::string &handle, const std::string& attribute_path, const char *value)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->setAttributeString( handle.c_str(), attribute_path.c_str(), value ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::SetAttributeValue (const std::string &handle, const std::string& attribute_path, const int &value)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->setAttributeInteger32( handle.c_str(), attribute_path.c_str(), value ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::SetAttributeValue (const std::string &handle, const std::string& attribute_path, void *value, unsigned int len)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->setAttributeByteArray( handle.c_str(), attribute_path.c_str(), value, len ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::AddRepeatEntry (const std::string &handle, const unsigned int entry)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->addRepeatEntry( handle.c_str(), entry ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::RemoveRepeatEntry (const std::string &handle, const unsigned int entry)
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->removeRepeatEntry( handle.c_str(), entry ) );
        }

        return ( false );
}

bool __fastcall TXMLSchema::Sort(const std::string &handle, const std::string &repeat_name, std::vector<std::string> &sort_fields )
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperStringCollection * collection = 0;

                try
                {
                        collection = &m_xmlSchemaWrapperFactory->createStringCollection();
                        for ( std::vector< std::string >::iterator
                                        where = sort_fields.begin();
                                  where != sort_fields.end();
                                  ++where )
                        {
                                collection->push_back( where->c_str() );
                        }
                        return ( m_xmlSchema->sort( handle.c_str(), repeat_name.c_str(), *collection ) );
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyStringCollection( *collection );
                        collection = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::SetAttributeValue (const std::string &handle, const std::string& attribute_path, const AnsiString &value)
{
        return SetAttributeValue( handle, attribute_path, value.c_str() );
}

bool __fastcall TXMLSchema::GetEnumerationValues (const std::string &handle, const char *enumeration, std::vector<std::string> &values)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperStringCollection * collection = 0;

                try
                {
                        collection = &m_xmlSchemaWrapperFactory->createStringCollection();
                        if ( m_xmlSchema->getEnumerationValues( handle.c_str(), enumeration, *collection ) )
                        {
                                values.clear();
                                const unsigned int size = collection->size();
                                for ( unsigned int position = 0; position < size; ++position )
                                {
                                        values.push_back( collection->operator[]( position ) );
                                }
                                return ( true );
                        }
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyStringCollection( *collection );
                        collection = 0;
                }
        }

        return ( false );
}

bool __fastcall TXMLSchema::GetEnumerationIdValue (const std::string &handle, const char *enumeration, const char *id, std::string &value)
{
        if ( m_xmlSchema )
        {
                IXmlSchemaWrapperString * enumerationValue = 0;

                try
                {
                        enumerationValue = &m_xmlSchemaWrapperFactory->createString();
                        if ( m_xmlSchema->getEnumerationIdValue( handle.c_str(), enumeration, id, *enumerationValue ) )
                        {
                                value = enumerationValue->c_str();
                                return ( true );
                        }
                }
                __finally
                {
                        m_xmlSchemaWrapperFactory->destroyString( *enumerationValue );
                        enumerationValue = 0;
                }
        }

        return ( false );
}


void __fastcall TXMLSchema::GetVersionInfo(AnsiString &module_name, AnsiString &module_version)
{
        module_name     = m_moduleName;
    module_version      = m_moduleVersion;
}

bool __fastcall TXMLSchema::Validate (const std::string &handle)
{
        if ( m_xmlSchema )
        {
                nullValidationObserver observer;

                return ( m_xmlSchema->validate( handle.c_str(), observer ) );
        }

        return ( false );
}

XMLSchema::IXmlSchemaWrapperFactory * TXMLSchema::GetSchemaWrapperFactory( void )
{
        return ( m_xmlSchemaWrapperFactory );
}

XMLSchema::IXmlSchemaWrapperSchema * TXMLSchema::GetSchema( void )
{
        return ( m_xmlSchema );
}

XMLSchema::IXmlSchemaWrapperElement * TXMLSchema::CreateSchemaElementAccess( const std::string & handle, const std::string & attribute_path ) const
{
        if ( m_xmlSchema )
        {
                return ( m_xmlSchema->createSchemaElement( handle.c_str(), attribute_path.c_str() ) );
        }

        return ( 0 );
}

void TXMLSchema::DestroySchemaElementAccess( const XMLSchema::IXmlSchemaWrapperElement& instance ) const
{
        if ( m_xmlSchema )
        {
                m_xmlSchema->destroySchemaElement( instance );
        }
}