UNI_SessionID.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.
 *
 * NAME:        UNI_SessionID.h ( UNI Library, C++)
 *
 * COMMENTS:
 *      
 */

#ifndef __UNI_SessionID_h__
#define __UNI_SessionID_h__

#include "UNI_API.h"
#include "UNI_ID.h"


// ============================================================================
/// A class representing a global unique ID in Houdini session
/// for items that can be found inside UNI graphs.
/// This class can encode two separate IDs: a graph ID and item's local ID 
/// into a single numeric value (UNI_ID::NumericType) stored in the base class.
/// It can also take the raw numerical value of the global unique ID too,
/// and thus can convert between the two representations.
class UNI_API UNI_SessionIDCoder : public UNI_ID
{
protected:
    /// Creates a unique global ID from a raw numerical value.
    explicit UNI_SessionIDCoder( UNI_ID::NumericType session_id_number )
        : UNI_ID( session_id_number ) {}

    /// Creates a unique ID that gobally identifies the item in Houdini session.
    /// The global ID is constructed based on the given graph ID 
    /// and the item's local ID within that graph.
    UNI_SessionIDCoder( UNI_GraphID graph_id, UNI_ID::NumericType local_id );

    /// Returns the graph ID encoded in this session ID.
    UNI_GraphID         decodeGraphID() const;

    /// Returns the numeric value of the item ID encoded in this session ID.
    UNI_ID::NumericType decodeItemID() const;
};
                           
// ============================================================================
/// A convenience class of converting between item's local and session IDs,
/// allowing using the formal ID types like UNI_NodeID 
/// (as the template argument).
template <typename LOCAL_ID>
class UNI_SessionID : public UNI_SessionIDCoder 
{
public:
    /// Creates a unique global ID from a raw numerical value.
    explicit UNI_SessionID( UNI_ID::NumericType id = INVALID_ID )
        : UNI_SessionIDCoder( id ) {}

    /// Creates a unique ID that gobally identifies the item in Houdini session.
    /// The global ID is constructed based on the given graph ID 
    /// and the item's local ID within that graph.
    UNI_SessionID( UNI_GraphID graph_id, LOCAL_ID local_id )
        : UNI_SessionIDCoder( graph_id, local_id.numericValue() )
    {}

    /// Returns the UNI graph ID encoded in this session ID.
    UNI_GraphID graphID() const
    { 
        return UNI_SessionIDCoder::decodeGraphID(); 
    }

    /// Returns the local ID of an item, locating it within the given graph.
    LOCAL_ID localID() const
    {
        return LOCAL_ID( UNI_SessionIDCoder::decodeItemID() );
    }
};


// ============================================================================
/// Aliases for UNI_SessionID template, to be used without template arguments.
using UNI_SessionNodeID         = UNI_SessionID< UNI_NodeID >;
using UNI_SessionPortID         = UNI_SessionID< UNI_PortID >;
using UNI_SessionStickyNoteID   = UNI_SessionID< UNI_StickyNoteID >;
using UNI_SessionWireID         = UNI_SessionID< UNI_WireID >;

// ============================================================================
/// String formatting ID for debug printouts, etc:
#define UNI_SESSION_ID_FORMATTER(UniSesID) \
inline size_t                                                               \
UTformatBuffer(char *buffer, size_t buffer_size, const UniSesID &v)         \
{                                                                           \
    UT::Format::Writer w(buffer, buffer_size);                              \
    UT::Format::Formatter f;                                                \
    return f.format(w, #UniSesID "({}={}:{})", {v.exintValue(),             \
            v.graphID().exintValue(), v.localID().exintValue()});           \
}                                                                           \
inline size_t                                                               \
UTformatBuffer(char *buffer, size_t buffer_size, const UT_Array<UniSesID> &v) \
{                                                                           \
    UT::Format::Writer w(buffer, buffer_size);                              \
    UT::Format::Formatter f;                                                \
    size_t bytesWritten = w("UT_Array<" #UniSesID ">([",                    \
                     sizeof("UT_Array<" #UniSesID ">([")-1);                \
    bool first = true;                                                      \
    for (auto &&item : v)                                                   \
    {                                                                       \
        bytesWritten += f.format(w, first ? "{}" : ", {}",                  \
                {item.exintValue()});                                       \
        first = false;                                                      \
    }                                                                       \
    bytesWritten += w("])", 2);                                             \
    return bytesWritten;                                                    \
}                                                                           \

UNI_SESSION_ID_FORMATTER( UNI_SessionNodeID )
UNI_SESSION_ID_FORMATTER( UNI_SessionPortID )
UNI_SESSION_ID_FORMATTER( UNI_SessionStickyNoteID )
UNI_SESSION_ID_FORMATTER( UNI_SessionWireID )

#endif