CH/CH_ChannelRef.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Neil Girdhar
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        CH_ChannelRef.h ( CH Library, C++)
 *
 * COMMENTS:
 */

#ifndef __CH_ChannelRef__
#define __CH_ChannelRef__

#include "CH_API.h"
#include <UT/UT_Algorithm.h>
#include <UT/UT_String.h>
#include <UT/UT_Hash.h>
#include "CH_Types.h"

class UT_StringArray;
class UT_Thing;

class CH_API CH_ChannelRef
{
public:

    CH_ChannelRef(const CH_ChannelRef &other)
    {
        // this is a bit faster than calling through setChannelRef,
        // since we avoid the allocString
        UT_ASSERT( other.myName );
        myNodeId = other.myNodeId;
        myIsTrack = other.myIsTrack;
        myName = other.myName;
    }

    CH_ChannelRef( int node_id, const char *name, bool is_track )
    {
        setChannelRef(node_id, name, is_track);
    }

    CH_ChannelRef()
    {
        clear();
    }

    ~CH_ChannelRef()
    {
        // do nothing for now -- maybe later free strings?
    }

    void         setChannelRef(int node_id, const char *name, bool is_track);

    void         clear();

    int          getNodeId() const { return myNodeId; }

    void         setNodeId( int new_id ) { myNodeId = new_id; }

    const char  *getName() const   { return myName; }

    bool         isTrack() const   { return myIsTrack; }

    bool         operator==( const CH_ChannelRef &other ) const
    {
        return myNodeId == other.myNodeId &&
               myIsTrack == other.myIsTrack &&
               myName == other.myName;
    }

    CH_ChannelRef &operator=( const CH_ChannelRef &other )
    {
        setChannelRef(other.myNodeId, other.myName, 
                      other.myIsTrack);
        return *this;
    }

    bool          operator<(const CH_ChannelRef &other) const
                  {
                      if (myNodeId < other.myNodeId)
                          return true;
                      // FIXME, we should sort by path, not by id
                      if (myNodeId == other.myNodeId &&
                              isLess(myName, other.myName))
                          return true;
                      return false;
                  }

    bool          operator>(const CH_ChannelRef &other) const
                  {
                      if (myNodeId > other.myNodeId)
                          return true;
                      // FIXME, we should sort by path, not by id
                      if (myNodeId == other.myNodeId &&
                              isGreater(myName, other.myName))
                          return true;
                      return false;
                  }

    unsigned int        hash() const;

private:
    bool         isLess(const char *str1, const char *str2) const
                 {
                     bool       rval;
                     if( !str1 )
                     {
                         if( str2 ) rval = true;// Yes, null ptr is < str2
                         else rval = false;
                     }
                     else
                     {
                         if( !str2) rval = false;// Nope, null is < str2
                         else rval = (strcmp(str1, str2) < 0) ? true : false;
                     }
                     return rval;
                 }
    bool         isGreater(const char *str1, const char *str2) const
                 {
                     bool       rval;
                     if( !str1 ) rval = false;
                     else
                     {
                         if( !str2 ) rval = true;// Yes, str1 is > null
                         else rval = (strcmp(str1, str2) > 0) ? true : false;
                     }
                     return rval;
                 }

    int          myNodeId:30;
    unsigned     myIsTrack:1;
    const char  *myName;
};

UT_SWAPPER_SIMPLE( CH_ChannelRef );

class CH_API CH_HashChRef: public UT_Hash
{
public:
    CH_HashChRef( const CH_ChannelRef &ref )
    : myRef(ref)
    { myHash = myRef.hash(); }

    virtual int          compare( const UT_Hash & a) const;
    virtual void         copy( const UT_Hash & a);

    virtual unsigned     hash() const { return myHash; }

    // When copying a CH_HashChRef, we copy the underlying CH_HashChRef.
    // We do this copy when an entry is added to a hash table.
    virtual UT_Hash     *copy() const;

    const CH_ChannelRef &getRef() const { return myRef; }

private:
    CH_ChannelRef        myRef;
    unsigned             myHash;
};

class CH_API CH_AddChanPathParms
{
public:
    CH_AddChanPathParms( UT_StringArray *chan_paths,
                                bool use_alias )
    {
        myPaths = chan_paths;
        myUseAlias = use_alias;
    }

    UT_StringArray      *myPaths;
    unsigned             myUseAlias;
};

class CH_API CH_AddChanRefParms
{
public:
    CH_AddChanRefParms( CH_ChannelRefList *chanrefs,
                                unsigned mask )
    {
        myChanRefs = chanrefs;
        myMask = mask;
    }

    CH_ChannelRefList   *myChanRefs;
    unsigned             myMask;
};

CH_API extern int
CHaddFullChannelPath(UT_Thing &, const UT_Hash &hash, void *data);

CH_API extern int
CHaddExposedChannel(UT_Thing &, const UT_Hash &hash, void *data);

CH_API extern int
CHaddExposedChanRef(UT_Thing &thing, const UT_Hash &hash, void *data);

CH_API extern int
CHcompareChanRefs(const CH_ChannelRef*, const CH_ChannelRef*);

CH_API extern bool
CHchannelsToChanRefs(const CH_ChannelList &channels, CH_ChannelRefList &refs);

CH_API extern bool
CHchanRefsToChannels(const CH_ChannelRefList &refs, CH_ChannelList &channels);

CH_API extern void
CHdisplayChanRefs(const CH_ChannelRefList &refs);

CH_API extern ostream &
operator<<(ostream &os, const CH_ChannelRef &ref);

#endif

---