archive_xmlstore_if.idl

Go to the documentation of this file.

#ifndef _ARCHIVE_XMLSTORE_IF_IDL_
#define _ARCHIVE_XMLSTORE_IF_IDL_

/*
 *    ALMA - Atacama Large Millimiter Array
 *    (c) European Southern Observatory, 2002
 *    Copyright by ESO (in the framework of the ALMA collaboration),
 *    All rights reserved
 *
 *    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 Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
 *    MA 02111-1307  USA
 */

#include <xmlentity.idl> 
#include <acscommon.idl>
#include <acscomponent.idl>

// HSO 2006-09-15: it seems that after a year of freedom from this bug, 
// we must again put the pragma after the includes. Otherwise a unit test in ARCHIVE/Archive failed,
// in which a C++ client accesses a Java component.
#pragma prefix "alma"


module xmlstore
{
        typedef string URI;
        typedef sequence <URI> URISeq;
        typedef string UniqueIdentifier;
                
        typedef sequence <UniqueIdentifier> UniqueIdentifierSeq;
        
         typedef xmlentity::XmlEntityStruct IdentifierRange;
         
        typedef sequence <string> StringSeq;
        
        exception ArchiveInternalError{};

        enum operationType {STORED_XML, UPDATED_XML, DELETED_XML}; // TODO add schema operations 

        struct XmlStoreNotificationEvent {
           string uid;       
           operationType operation;
        };
        
        const string CHANNELNAME = "xmlstore";
        interface Identifier : ACS::ACSComponent
        {
                exception NotAvailable{};

                exception NotFound{};

                UniqueIdentifierSeq getUIDs(in short number) 
                        raises (NotAvailable);
                        
                UniqueIdentifier getIdNamespace() 
                        raises (NotAvailable);
                        
                IdentifierRange getNewRange()
                        raises (NotAvailable);
                        
                IdentifierRange getNewRestrictedRange(in long number, in string user)
                        raises (NotAvailable);
                        
                IdentifierRange getExistingRange(in URI identifier, in string user)
                        raises (NotFound);

                boolean checkUIDsyntax(in URI identifier);
        };
        
        interface Cursor : ACS::OffShoot
        {
                struct QueryResult 
                {
                        URI identifier;
                        string xml;
                };
                
                typedef sequence <QueryResult> QueryResultSeq;
                
                // might need to add some exceptions

                boolean hasNext()
                        raises (ArchiveInternalError);
                        
                QueryResult next()
                        raises (ArchiveInternalError);
                        
                QueryResultSeq nextBlock(in short size)
                        raises (ArchiveInternalError);
                
                oneway void close(); 
        };

        interface Operational : ACS::OffShoot
        {       
                struct StatusStruct
                {
                        URI schema;
                        string owner;
                        string locks;
                        boolean deleted;
                        boolean dirty;
                        boolean hidden;
                };
                exception AlreadyThere{};
                exception NotYetThere{};
                exception IllegalEntity{};
                exception DirtyEntity{};
                exception MalformedURI{};
                exception NotFound{};

                exception TimestampInconsistency{};

                boolean exists(in URI identifier)
                        raises (ArchiveInternalError, NotFound, MalformedURI, DirtyEntity);
                
                void store(in xmlentity::XmlEntityStruct entity)
                        raises (ArchiveInternalError, IllegalEntity);
                        
                void update(in xmlentity::XmlEntityStruct entity)
                        raises (ArchiveInternalError, IllegalEntity, TimestampInconsistency);
                
                void forceUpdate(in xmlentity::XmlEntityStruct entity)
                        raises (ArchiveInternalError, IllegalEntity, TimestampInconsistency);
                        
                void updateXML(in URI uid, in string schema, in wstring newChild) raises (ArchiveInternalError, IllegalEntity, MalformedURI, NotYetThere); 
                
                xmlentity::XmlEntityStruct retrieve(in URI identifier)
                        raises (ArchiveInternalError, NotFound, MalformedURI, DirtyEntity);
                                
                StringSeq retrieveFragment(in URI identifier, in string id)
                        raises (ArchiveInternalError, NotFound, MalformedURI, DirtyEntity);
                        
                xmlentity::XmlEntityStruct updateRetrieve(in URI identifier)
                        raises (ArchiveInternalError, NotFound, MalformedURI, DirtyEntity);
                        
                xmlentity::XmlEntityStruct retrieveDirty(in URI identifier)
                        raises (ArchiveInternalError, NotFound, MalformedURI);
                        
                void delete(in URI identifier)
                        raises (ArchiveInternalError, NotFound, MalformedURI);
                        
                void undelete(in URI identifier)
                        raises (ArchiveInternalError, NotFound, MalformedURI);
                
                StatusStruct status(in URI identifier)
                        raises (ArchiveInternalError, NotFound, MalformedURI);
                
                Cursor query( in wstring query, in string schema)
                raises (ArchiveInternalError);
                Cursor queryContent( in wstring query, in string schema)
                        raises (ArchiveInternalError);
                        
                Cursor queryDirty( in wstring query, in string schema)
                        raises (ArchiveInternalError);

                URISeq queryUIDs( in wstring query, in string schema)
                        raises (ArchiveInternalError);          

                URISeq queryUIDsDirty( in wstring query, in string schema)
                        raises (ArchiveInternalError);
                
                URISeq queryRecent( in string schemaname, in string timestamp)
                        raises (ArchiveInternalError);

                
                void addElement(in URI uid, in string schema, in wstring xPath, in wstring xmlElement)
                        raises (ArchiveInternalError, IllegalEntity, MalformedURI, NotYetThere);
        
                void updateElement(in URI uid, in string schema, in wstring xPath, in wstring xmlElement)
                        raises (ArchiveInternalError, IllegalEntity, MalformedURI, NotYetThere);

                        
                void deleteElement(in URI uid, in string schema, in wstring xPath)
                        raises (ArchiveInternalError, IllegalEntity, MalformedURI, NotYetThere);

                
                void close(in string password)
                        raises (ArchiveInternalError);
                        
        };

        interface Administrative : ACS::OffShoot, ACS::PingableResource
        {
                exception NotFound{};
                exception MalformedURI{};

                // boolean ping();

                void init(in string password)
                        raises (ArchiveInternalError);

                void reinit(in string password)
                        raises (ArchiveInternalError);

                void remove(in URI identifier, in boolean deep)
                        raises (NotFound,MalformedURI,ArchiveInternalError);

                void cleanTestArea()
                        raises (ArchiveInternalError);
                
                string config(in string name);
                
                void close(in string password)
                        raises (ArchiveInternalError);
        };
        
        interface ArchiveConnection : ACS::ACSComponent
        {
                exception UserDoesNotExistException{};
                exception PermissionException{};
                exception ArchiveException{};
                
                Operational getOperational(in string user) 
                        raises (UserDoesNotExistException,ArchiveException,PermissionException);

                Administrative getAdministrative(in string user) 
                        raises (UserDoesNotExistException,ArchiveException,PermissionException);
        
        };
};


#endif /* _ARCHIVE_XMLSTORE_IF_IDL_ */