kfbxquery.h

Go to the documentation of this file.

#ifndef FBXFILESDK_FBXCORE_KFBXQUERY_H
#define FBXFILESDK_FBXCORE_KFBXQUERY_H

/**************************************************************************************

 Copyright (C) 2001 - 2010 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.

 The coded instructions, statements, computer programs, and/or related material 
 (collectively the "Data") in these files contain unpublished information 
 proprietary to Autodesk, Inc. and/or its licensors, which is protected by 
 Canada and United States of America federal copyright law and by international 
 treaties. 
 
 The Data may not be disclosed or distributed to third parties, in whole or in
 part, without the prior written consent of Autodesk, Inc. ("Autodesk").

 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR ARISING
 BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES OF TITLE, 
 NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR USE. 
 WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT WARRANT THAT THE OPERATION
 OF THE DATA WILL BE UNINTERRUPTED OR ERROR FREE. 
 
 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR EXPENSES
 OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE DAMAGES OR OTHER
 SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS OF PROFITS, REVENUE
 OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR DAMAGES OF ANY KIND),
 HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF LIABILITY, WHETHER DERIVED
 FROM CONTRACT, TORT (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE), OR OTHERWISE,
 ARISING OUT OF OR RELATING TO THE DATA OR ITS USE OR ANY OTHER PERFORMANCE,
 WHETHER OR NOT AUTODESK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS
 OR DAMAGE. 

**************************************************************************************/
#include <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/components/kbaselib/klib/kmap.h>
#include <fbxfilesdk/fbxcore/kfbxpropertydef.h>
#include <fbxfilesdk/kfbxplugins/kfbxproperty.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

    /***********************************************
      KFbxQuery
    ************************************************/

    class KFBX_DLL KFbxQuery {
        // Overridable Test functions
        public:
            KFBXNEW_DECLARE_FRIEND
            virtual kFbxFilterId                    GetUniqueId() const     { return 0x1452e230; }
            
            virtual bool IsValid(KFbxProperty const &pProperty) const;

            virtual bool IsValid(KFbxProperty const &pProperty,kFbxConnectionType pType) const;

            virtual bool IsEqual(KFbxQuery *pOtherQuery)    const;

        public:
            void                                    Ref();
            void                                    Unref();
        protected:
            KFbxQuery();
            virtual ~KFbxQuery();
        private:
            class KFbxInternalFilter : public KFbxConnectionPointFilter{
                public:
                    KFbxInternalFilter(KFbxQuery *pQuery);
                    ~KFbxInternalFilter();

                // internal functions
                public:
                    KFbxConnectionPointFilter*      Ref();
                    void                            Unref();
                    kFbxFilterId                    GetUniqueId() const { return mQuery->GetUniqueId(); }
                    bool                            IsValid             (KFbxConnectionPoint*   pConnect) const;
                    bool                            IsValidConnection   (KFbxConnectionPoint*   pConnect,kFbxConnectionType pType) const;
                    bool                            IsEqual             (KFbxConnectionPointFilter* pConnectFilter) const;
                public:
                    KFbxQuery*      mQuery;

            };

            KFbxInternalFilter  mFilter;
            int                 mRefCount;

            friend class KFbxProperty;
            friend class KFbxInternalFilter;
        };

    /***********************************************
      KFbxQueryOperator (binary operators)
    ************************************************/
    enum eFbxQueryOperator { eFbxAnd,eFbxOr } ;

    class KFBX_DLL KFbxQueryOperator : public KFbxQuery {
        //
        public:
            KFBXNEW_DECLARE_FRIEND
            static KFbxQueryOperator* Create(KFbxQuery* pA,eFbxQueryOperator pOperator,KFbxQuery* pB);

        protected:
            KFbxQueryOperator(KFbxQuery* pA,eFbxQueryOperator pOperator,KFbxQuery* pB);
            virtual ~KFbxQueryOperator();

        // Test functions
        public:

            virtual kFbxFilterId    GetUniqueId() const{ return 0x945874; }

            virtual bool IsValid(KFbxProperty const &pProperty) const;

            virtual bool IsValid(KFbxProperty const &pProperty,kFbxConnectionType pType) const;
            
            virtual bool IsEqual(KFbxQuery *pOtherQuery)    const;
        private:
            KFbxQuery           *mA,*mB;
            eFbxQueryOperator   mOperator;
    };

    /***********************************************
      KFbxUnaryQueryOperator
    ************************************************/
    enum eFbxUnaryQueryOperator { eFbxNot };

    class KFBX_DLL KFbxUnaryQueryOperator : public KFbxQuery {
        //
        public:
            KFBXNEW_DECLARE_FRIEND
            static KFbxUnaryQueryOperator* Create(KFbxQuery* pA,eFbxUnaryQueryOperator pOperator);

        protected:
            KFbxUnaryQueryOperator(KFbxQuery* pA,eFbxUnaryQueryOperator pOperator);
            virtual ~KFbxUnaryQueryOperator();

        // Test functions
        public:

            virtual kFbxFilterId    GetUniqueId() const{ return 0x945874BB; }

            virtual bool IsValid(KFbxProperty const &pProperty) const;

            virtual bool IsValid(KFbxProperty const &pProperty,kFbxConnectionType pType) const;

            virtual bool IsEqual(KFbxQuery *pOtherQuery)    const;
        private:
            KFbxQuery                *mA;
            eFbxUnaryQueryOperator   mOperator;
    };

    /***********************************************
      KFbxQueryClassId -- match anywhere in the hierarchy of an object.
    ************************************************/
    class KFBX_DLL KFbxQueryClassId : public KFbxQuery {
        //
        public:
            KFBXNEW_DECLARE_FRIEND
            static KFbxQueryClassId* Create(kFbxClassId pClassId);

        protected:
            KFbxQueryClassId(kFbxClassId pClassId);

        // Test functions
        public:

            virtual kFbxFilterId    GetUniqueId() const{ return 0x14572785; }

            virtual bool IsValid(KFbxProperty const &pProperty) const;

            virtual bool IsValid(KFbxProperty const &pProperty,kFbxConnectionType pType) const;

            virtual bool IsEqual(KFbxQuery *pOtherQuery)    const;
        private:
            kFbxClassId             mClassId;
    };

    /***********************************************
      KFbxQueryIsA -- Exact match.
    ************************************************/

    class KFBX_DLL KFbxQueryIsA : public KFbxQuery {
        //
        public:
            KFBXNEW_DECLARE_FRIEND
            static KFbxQueryIsA* Create(kFbxClassId pClassId);

        protected:

            KFbxQueryIsA(kFbxClassId pClassId);

        // Test functions
        public:

            virtual kFbxFilterId    GetUniqueId() const{ return 0x1457278F; }

            virtual bool IsValid(KFbxProperty const &pProperty) const;

            virtual bool IsValid(KFbxProperty const &pProperty,kFbxConnectionType pType) const;

            virtual bool IsEqual(KFbxQuery *pOtherQuery)    const;
        private:
            kFbxClassId             mClassId;
    };

    /***********************************************
      KFbxQueryProperty
    ************************************************/

    class KFBX_DLL KFbxQueryProperty : public KFbxQuery {
        //
        public:
            KFBXNEW_DECLARE_FRIEND
            static KFbxQueryProperty* Create();

        protected:
            KFbxQueryProperty();

        // Test functions
        public:

            virtual kFbxFilterId    GetUniqueId() const{ return 0x9348203; }

            virtual bool IsValid(KFbxProperty const &pProperty) const;

            virtual bool IsValid(KFbxProperty const &pProperty,kFbxConnectionType pType) const;

            virtual bool IsEqual(KFbxQuery *pOtherQuery)    const;
        private:
    };

    /***********************************************
      KFbxQueryConnectionType
    ************************************************/

    class KFBX_DLL KFbxQueryConnectionType : public KFbxQuery {
        //
        public:
            KFBXNEW_DECLARE_FRIEND

            static KFbxQueryConnectionType* Create(kFbxConnectionType pConnectionType);

        protected:
            KFbxQueryConnectionType(kFbxConnectionType pConnectionType);

        // Test functions
        public:

            virtual kFbxFilterId    GetUniqueId() const{ return 0x14587275; }

            virtual bool IsValid(KFbxProperty const &pProperty) const;

            virtual bool IsValid(KFbxProperty const &pProperty,kFbxConnectionType pType) const;

            virtual bool IsEqual(KFbxQuery *pOtherQuery)    const;
        private:
            kFbxConnectionType              mConnectionType;
    };

    /***********************************************
      KFbxCriteria
    ************************************************/

    class KFBX_DLL KFbxCriteria {
        public:
            static KFbxCriteria ConnectionType(kFbxConnectionType pConnectionType)
            {
                return KFbxCriteria(KFbxQueryConnectionType::Create(pConnectionType));
            }

            static KFbxCriteria ObjectType(kFbxClassId pClassId)
            {
                return KFbxCriteria(*sCache.GetObjectType(pClassId));
            }

            static KFbxCriteria ObjectIsA(kFbxClassId pClassId)
            {
                return KFbxCriteria(KFbxQueryIsA::Create(pClassId));
            }

            static KFbxCriteria Property()
            {
                return KFbxCriteria(KFbxQueryProperty::Create());
            }

            inline KFbxCriteria()
                : mQuery(0)
            {
            }

            inline KFbxCriteria(KFbxCriteria const &pCriteria)
                : mQuery(pCriteria.mQuery)
            {
                if( mQuery )
                    mQuery->Ref();
            }

            inline ~KFbxCriteria()
            {
                if( mQuery )
                    mQuery->Unref();
            }

            inline KFbxCriteria &operator=(KFbxCriteria const &pCriteria)
            {
                if( this != &pCriteria )
                {
                    KFbxQuery* lQuery = mQuery;
                    mQuery = pCriteria.mQuery;

                    if( mQuery )
                        mQuery->Ref();

                    if( lQuery )
                        lQuery->Unref();
                }

                return *this;
            }
            inline KFbxCriteria operator && (KFbxCriteria const &pCriteria) const
            {
                return KFbxCriteria(KFbxQueryOperator::Create(GetQuery(),eFbxAnd,pCriteria.GetQuery()));
            }

            inline KFbxCriteria operator || (KFbxCriteria const &pCriteria) const
            {
                return KFbxCriteria(KFbxQueryOperator::Create(GetQuery(),eFbxOr,pCriteria.GetQuery()));
            }

            inline KFbxCriteria operator !() const
            {
                return KFbxCriteria(KFbxUnaryQueryOperator::Create(GetQuery(), eFbxNot));
            }
            inline KFbxQuery*   GetQuery() const { return mQuery; }

            //
            //  WARNING!
            //
            //  Anything beyond these lines may not be documented accurately and is
            //  subject to change without notice.
            //

#ifndef DOXYGEN_SHOULD_SKIP_THIS

        private:
            KFbxQuery*  mQuery;
            inline KFbxCriteria(KFbxQuery* pQuery)
                : mQuery(pQuery)
            {
            }

            // KFbxCriteriaCache caches KFbxCriteria instances for reuse
            KFBXNEW_DECLARE_FRIEND
            class KFbxCriteriaClassIdCompare
            {
            public:
                inline int operator() (kFbxClassId const& pKeyA, kFbxClassId const& pKeyB) const
                {
                    const KFbxClassIdInfo* lKeyA = pKeyA.GetClassIdInfo();
                    const KFbxClassIdInfo* lKeyB = pKeyB.GetClassIdInfo();
                    return (lKeyA > lKeyB) ? 1 : (lKeyA < lKeyB) ? -1 : 0;
                }
            };

            class KFbxCriteriaCache
            {
            public:
                KFbxCriteriaCache();
                ~KFbxCriteriaCache();

                inline KFbxCriteria* GetObjectType(kFbxClassId pClassId)
                {
                    KFbxCriteriaCacheMap::RecordType* lRecord = mObjectTypeCriteria.Find(pClassId);
                    if (lRecord == NULL)
                    {
                        KFbxCriteria* lCriteria = FbxSdkNew<KFbxCriteria>(KFbxQueryClassId::Create(pClassId));
                        mObjectTypeCriteria.Insert(pClassId, lCriteria);
                        return lCriteria;
                    }
                    return lRecord->GetValue();
                }

            private:
                typedef KMap<kFbxClassId, KFbxCriteria*, KFbxCriteriaClassIdCompare> KFbxCriteriaCacheMap;
                KFbxCriteriaCacheMap mObjectTypeCriteria;
            };
            static KFbxCriteriaCache sCache;
#endif
    };

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_FBXCORE_KFBXQUERY_H