Application: gvSIG desktop

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

** Copyright 2003 Earth Resource Mapping Ltd.

** This document contains proprietary source code of

** Earth Resource Mapping Ltd, and can only be used under

** one of the three licenses as described in the 

** license.txt file supplied with this distribution. 

** See separate license.txt file for license details 

** and conditions.

**

** This software is covered by US patent #6,442,298,

** #6,102,897 and #6,633,688.  Rights to use these patents 

** is included in the license agreements.

**

** FILE:     $Archive: /NCS/Source/include/NCSJPCNode.h $

** CREATED:  14/03/2003 3:27:34 PM

** AUTHOR:   Simon Cope

** PURPOSE:  CNCSJPCNode class header

** EDITS:    [xx] ddMmmyy NAME COMMENTS

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

#ifndef NCSJPCNODE_H

#define NCSJPCNODE_H

#ifndef NCSJPCBUFFER_H

#include "NCSJPCBuffer.h"

#endif // NCSJPCBUFFER_H

        /**

         * CNCSJPCMarker class - the base JPC codestream marker.

         * 

         * @author       Simon Cope

         * @version      $Revision: 3538 $ $Author: nacho $ $Date: 2006-01-09 12:56:54 +0100 (Mon, 09 Jan 2006) $ 

         */        

class NCSJPC_EXPORT_ALL CNCSJPCNode: public CNCSJPCBuffer, public CNCSError {

public:

        class NCSJPC_EXPORT_ALL CNCSJPCNodeTracker {

        public:

                CNCSJPCNodeTracker(char *pClassName, size_t nNodeSize);

                virtual ~CNCSJPCNodeTracker();

                void Add();

                void Remove();

                void AddMem(UINT64 nSize);

                void RemoveMem(UINT64 nSize);

                INT32 m_nNodesTotal;                // Total # nodes allocated

                INT64 m_nMemTotal;                        // Total Mem allocated

                char        m_szNodeName[32];        // Name of this node

                INT32 m_nNodeSize;                        // Size of a single node

                static INT32 sm_nNodesTotal;        // Total # nodes allocated globally

                static INT64 sm_nMemTotal;                // Total # nodes allocated globally

                static std::vector<CNCSJPCNodeTracker*> *sm_pTrackers;

        };

                /** Default constructor, initialises members */

        CNCSJPCNode();

                /** Virtual destructor */

        virtual ~CNCSJPCNode();

        typedef void *ContextID;

        class NCSJPC_EXPORT_ALL Context {

        public:

                Context();

                virtual ~Context();

                virtual UINT32 NrInputs();

                virtual class CNCSJPCNode *GetInput(UINT32 n);

                virtual void SetInput(UINT32 n, CNCSJPCNode *pNode);

                virtual void SetInputBuffers(UINT32 nInput, UINT8 nBuffers);

                virtual CNCSJPCBuffer *GetInputBuffer(UINT32 nInput, UINT8 nBuffer);

                virtual CNCSJPCBuffer *FindInputBuffer(UINT32 nInput, UINT32 &nBuffer, CNCSJPCRect &r, bool &bFound, CNCSJPCBuffer::Type eType);

                virtual void AddInput(CNCSJPCNode *pNode);

                Context operator=(const Context &src);

        private:

                class NCSJPC_EXPORT_ALL CNCSJPCNodeInput {

                public:

                        class CNCSJPCNode *m_pNode;

                        CNCSJPCBufferCache m_Buffers;

                        virtual ~CNCSJPCNodeInput();

                };

                        /** Link to input nodes */

                std::vector<CNCSJPCNodeInput>m_Inputs;

        };

                /** 

                 * Link a node as the unput to this node.

                 * @param                nCtx                Read context

                 * @param                nInputs                Number of inputs to this node

                 * @param                pInput                First CNCSJPCNode to use as input to this node.

                 * @param                ...                        Additional inputs where required (eg, MCT)

                 * @return      bool                true on success, else false on error.

                 */

        virtual bool Link(ContextID nCtx, UINT16 nInputs, CNCSJPCNode *pInput, ...);

                /** 

                 * Add a node as an input to this node.

                 * @param                nCtx                Read context

                 * @param                pNode                Input node to add

                 * @return      bool                true on success, else false on error.

                 */

        virtual bool AddInput(ContextID nCtx, CNCSJPCNode *pInput) { GetContext(nCtx)->AddInput(pInput); return(true); };

                /** 

                 * UnLink a node as the unput to this node.

                 * @param                nCtx                Read context

                 * @return      bool                true on success, else false on error.

                 */

        virtual bool UnLink(ContextID nCtx, UINT16 nInputs = 0);

                /** 

                 * Read a BufferType line from the input.

                 * @param                nCtx                Read context

                 * @param                pDst                Destination buffer.

                 * @param                iComponent        Output Component

                 * @return      bool                true on succes, else false.

                 */

        virtual bool ReadLine(ContextID nCtx, CNCSJPCBuffer *pDst, UINT16 iComponent);

        virtual bool ReadInputLines(ContextID nCtx, UINT32 ninputs, ...);

                /** 

                 * Write a BufferType line to the output.

                 * @param                nCtx                Context

                 * @param                pSrc                Source buffer.

                 * @param                iComponent        Output Component

                 * @return      bool                true on succes, else false.

                 */

        virtual bool WriteLine(ContextID nCtx, CNCSJPCBuffer *pSrc, UINT16 iComponent) { return(false); };

                /** 

                 * Get the input error 

                 * @param                nCtx                Context id for input

                 * @return                CNCSError        CNCSError value of the input to this node.

                 */

        CNCSError GetError(ContextID nCtx);

protected:

        class ContextAutoPtr: public std::auto_ptr<Context> {

        public:

                ContextAutoPtr() {};

                ContextAutoPtr(Context *s): std::auto_ptr<Context>(s) {};

                ContextAutoPtr(const ContextAutoPtr &s) { 

                        ContextAutoPtr P(s.get());

                        *this = P;

                };

                ~ContextAutoPtr() {};

        };

        std::map<ContextID, ContextAutoPtr> *m_pContext;/*std::auto_ptr<Context>*/

                /**

                 * Get the context for the given ContextID

                 * @param                nCtx                ContextID to retrive context

                 * @param                bAutoConstruct Autoconstruct a new context for this ContextID if one doesn't exist

                 * @return                Context*        Context for given ID.

                 */

        virtual Context *GetContext(ContextID nCtx, bool bAutoConstruct = true);

                /**

                 * Get the context for the given ContextID

                 * @param                nCtx                ContextID to set

                 * @param                pCtx                Context to set

                 * @return                Context*        Context for given ID.

                 */        

        virtual void SetContext(ContextID nCtx, Context *pCtx);

private:

};

#endif // !NCSJPCNODE_H