oaCommonIBase.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaCommonIBase.h
//
// This file contains the definition for base interface class.
//
//  IBase
//      This is the base class for the interface classes.
//
//  IFactory
//      This is the abstract factory. This factory is implemented by the plug-in
//      and is used to create instances of the interface objects as needed.
//
//  IException
//     This is an abstract class which can be used by the plug-in
//     implementation to pass an exception back to the application side.
//
//  IString
//     This is a simple string interface.
//
//  IIter
//      This is a templated abstract class used to iterate generic collections.
//      The template parameter determines the type of object being served from
//      the iterator. Typically, a typedef will be used to define a specific
//      expansion of the interface, followed by a declaration of that
//      expansion's interface id (the template doesn't have an id, since it
//      doesn't define a specific expansion of the interface). For Example:
//
//      typedef IIter<IBase*>               IBaseIter;
//      extern OA_COMMON_DLL_API const Guid IID_IBaseIter;
//
//      defines the specific expansion and interface id of an iterator for the
//      IBase interface pointer.
//
//      The implementor of an iterator based on an expansion of IIter can use
//      any appropriate collection class as long as it can be accessed using an
//      "iterator" or "enumerator" pattern.
//      For example, if the following interfaces are defined:
//
//      class IFoo : public IBase {
//          void                doStuff() = 0;
//      };
//      extern OA_COMMON_DLL_API const Guid IID_IFoo;
//
//      typedef IIter<IFoo*>                IFooIter;
//      extern OA_COMMON_DLL_API const Guid IID_IFooIter;
//
//      Then an example of client code using this interface would be:
//
//      IFooIter        *it = someContainer->getItems();
//      IFoo            *obj;
//      while (it->next(obj)) {
//          obj->doStuff();
//          obj->release();
//      }
//
//  ISequence
//      This is a templated abstract class that extends the funtionality found
//      on the IIter to add the ability to modify the underlying collection.
//      These functions all operate relative to the "current" element. That is,
//      "insert" will insert an elememt before the current elememt while
//      "append" inserts it *after* the current element. The "remove" method
//      will remove the current element from the collection (and set the
//      "current" element to the previous element - so that calling "next" will
//      have the effect of going to the element that would have been next if
//      "remove" hadn't been called. The "replace" function will replace the
//      current element with the one passed in. The partial specialization of
//      ISequence is purly an optimization so that sequences of pointers (such
//      as interface pointers, which will likely represent the bulk of usage)
//      will be passed in as "Type *" rather than "const Type *&".
//      The template considerations work identially to the IIter as described
//      above.
//
//  IBaseIter
//      This is a particular expansion of the IIter interface to iterate
//      pointers to components via their IBase interfaces.
//
//  IBaseSequence
//      This is a particular expansion of the ISequence interface to handle
//      pointers to components via their IBase interfaces.
//
//  ISecureStringCopy
//      This is a class used to provide a secure string copy.
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//                Copyright 2002-2009 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: icftcm $
//  $Revision: #1 $
//  $Date: 2010/08/09 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaCommonIBase_P)
#define oaCommonIBase_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaCommonTypes.h"


// *****************************************************************************
// Declare and define types in the oaCommon namespace
// *****************************************************************************
BEGIN_OA_COMMON_NAMESPACE

USE_OA_NAMESPACE

// *****************************************************************************
// IBase
// *****************************************************************************
extern OA_COMMON_DLL_API const Guid IID_IBase;

class OA_COMMON_DLL_API IBase {
public:
    enum Status {
        cOK                 = 0,
        cFail               = 1,
        cNoInterface        = 2,
        cNotFound           = 3,
        cLibraryNotFound    = 4,
        cSymbolNotFound     = 5,
        cNotImplemented     = 6,
        cOutOfMemory        = 7,
        cInvalidArg         = 8,
        cNoAggregation      = 9,
        cErrorInRegFile     = 10,
        cClassNotRegistered = 11,
        cIncompatible       = 12
    };


    virtual long            queryInterface(const Guid   &id,
                                           void         **iPtr) = 0;
    virtual unsigned long   addRef() = 0;
    virtual unsigned long   release() = 0;

    static const Guid       &getId();

    static bool             s_refCountDisabled;
};



// *****************************************************************************
// IFactory
// *****************************************************************************
extern OA_COMMON_DLL_API const Guid IID_IFactory;

class OA_COMMON_DLL_API IFactory : public IBase {
public:
    virtual oa::oaUInt4     createInstance(IBase        *reserved,
                                           const Guid   &id,
                                           void         **iPtr) = 0;

    static const Guid       &getId();
};



// *****************************************************************************
// ICompatiblity
// *****************************************************************************
extern OA_COMMON_DLL_API const Guid IID_ICompatibility;

class OA_COMMON_DLL_API ICompatibility : public IBase {
public:
    virtual bool            validate() = 0;

    static const Guid       &getId();
};



// *****************************************************************************
// IException
// *****************************************************************************
class OA_COMMON_DLL_API IException {
public:
    virtual oa::oaUInt4     getMsgId() const = 0;
    virtual const char      *getMsg() const     = 0;
};



// *****************************************************************************
// IPlugInException
// *****************************************************************************
class OA_COMMON_DLL_API IPlugInException : public IException {
public:
    virtual oa::oaUInt4     getStatus() const = 0;
};



// *****************************************************************************
// IString
// *****************************************************************************
extern OA_COMMON_DLL_API const Guid IID_IString;

class OA_COMMON_DLL_API IString : public IBase {
public:
    virtual const char      *str() = 0;

    static const Guid       &getId();
};



// *****************************************************************************
// IIter
// *****************************************************************************
template<class T, const Guid *G>
class IIter : public IBase {
public:
    typedef T               Type;
    typedef T               IType;

    virtual bool            next(T &objOut) = 0;
    virtual void            reset() = 0;

    static const Guid       &getId();
};



// *****************************************************************************
// IIter
// *****************************************************************************
template<class T, const Guid *G>
class IIter<T*, G> : public IBase {
public:
    typedef T               *Type;
    typedef T               IType;

    virtual bool            next(T *&objOut) = 0;
    virtual void            reset() = 0;

    static const Guid       &getId();
};



// *****************************************************************************
// ISequence
// *****************************************************************************
template<class T, const Guid *SeqId, const Guid *IterId>
class ISequence : public IIter<T, IterId> {
public:
    typedef T               SType;

    virtual oa::oaUInt4     count() = 0;
    virtual void            insert(const T &objIn) = 0;
    virtual void            append(const T &objIn) = 0;
    virtual void            remove() = 0;
    virtual void            replace(const T &objIn) = 0;

    static const Guid       &getId();
};



// *****************************************************************************
// ISequence
// *****************************************************************************
template<class T, const Guid *SeqId, const Guid *IterId>
class ISequence<T*, SeqId, IterId> : public IIter<T*, IterId> {
public:
    typedef T               SType;

    virtual oa::oaUInt4     count() = 0;
    virtual void            insert(T *objIn) = 0;
    virtual void            append(T *objIn) = 0;
    virtual void            remove() = 0;
    virtual void            replace(T *objIn) = 0;

    static const Guid       &getId();
};



// *****************************************************************************
// IBaseIter
// *****************************************************************************
extern OA_COMMON_DLL_API const Guid IID_IBaseIter;
typedef IIter<IBase*, &IID_IBaseIter> IBaseIter;



// *****************************************************************************
// IBaseSequence
// *****************************************************************************
extern OA_COMMON_DLL_API const Guid IID_IBaseSequence;
typedef ISequence<IBase*, &IID_IBaseSequence, &IID_IBaseIter> IBaseSequence;



// *****************************************************************************
// ISecureStringCopy
// *****************************************************************************
class OA_COMMON_DLL_API ISecureStringCopy {
public:
    static void             copy(oaChar         *strDest,
                                 const oaChar   *strSrc,
                                 oaUInt4        maxLength);

};



END_OA_COMMON_NAMESPACE

#endif

Return to top of page

Copyright © 2002 - 2010 Cadence Design Systems, Inc.
All Rights Reserved.