Exemple #1
0
/*))
 ((     Node make/dispose. Note, we do initialize/destroy node name
  ))    here, but Constructor could redefine it.
 ((*/
LIB_EXPORT
rc_t CC
XFSNodeInit (
            const struct XFSNode * self,
            const char * NodeName
)
{
    return XFSNodeInitVT ( self, NodeName, NULL );
}   /* XFSNodeInit () */
Exemple #2
0
static
rc_t CC
XFSEncNodeMake (
    struct XFSNode ** Node,
    const char * Name,
    const struct XFSEncEntry * Entry
)
{
    rc_t RCt;
    struct XFSEncNode * xNode;

    RCt = 0;
    xNode = NULL;

    XFS_CSAN ( Node )

    XFS_CAN ( Node )
    XFS_CAN ( Name )
    XFS_CAN ( Entry )

    xNode = calloc ( 1, sizeof ( struct XFSEncNode ) );
    if ( xNode == NULL ) {
        return XFS_RC ( rcNull );
    }

    RCt = XFSNodeInitVT (
                    & ( xNode -> node ),
                    Name,
                    ( const union XFSNode_vt * ) & _sEncNodeVT_v1
                    );

    if ( RCt == 0 ) {
        RCt = XFSEncEntryAddRef ( Entry );
        if ( RCt == 0 ) {
            xNode -> entry = Entry;

            * Node = & ( xNode -> node );
        }
    }

    if ( RCt != 0 ) {
        if ( xNode != NULL ) {
            RCt = XFSNodeDispose ( & ( xNode -> node ) );
        }
    }

    return RCt;
}   /* XFSEncNodeMake () */
Exemple #3
0
static
rc_t CC
_BogusNodeMake ( 
            const char * NodeName,
            bool NotFoundType,
            const struct XFSBogusNode ** Node )
{
    rc_t RCt;
    struct XFSBogusNode * TheNode;

    RCt = 0;
    TheNode = NULL;

    if ( NodeName == NULL || Node == NULL ) {
        return XFS_RC ( rcNull );
    }
    * Node = NULL;

    TheNode = calloc ( 1, sizeof ( struct XFSBogusNode ) );
    if ( TheNode == NULL ) {
        RCt = XFS_RC ( rcExhausted );
    }
    else {
        TheNode -> NotFoundType = NotFoundType;

        RCt = XFSNodeInitVT (
                        & ( TheNode -> Node ),
                        NodeName,
                        ( const union XFSNode_vt * ) & _sBogusNodeVT_v1
                        );

        if ( RCt == 0 ) {
            * Node = TheNode;
        }
        else {
            XFSNodeDispose ( ( const struct XFSNode * ) TheNode );
        }
    }
/*
printf ( "_BogusNodeMake ( %s, 0x%p )\n", NodeName, ( void * ) TheNode );
*/

    return RCt;
}   /* _BogusNodeMake () */
Exemple #4
0
LIB_EXPORT
rc_t CC
XFSDocNodeMakeWithFlavor (
            struct XFSNode ** Node,
            const struct XFSDoc * Doc,
            const char * Name,
            const char * Perm,          /* Could be NULL */
            uint32_t Flavor
)
{
    rc_t RCt;
    struct XFSDocNode * TheNode;

    RCt = 0;
    TheNode = NULL;

    if ( Node != NULL ) {
        * Node = NULL;
    }

    if ( Node == NULL || Name == NULL || Doc == NULL ) {
        return XFS_RC ( rcNull );
    }

    TheNode = calloc ( 1, sizeof ( struct XFSDocNode ) );
    if ( TheNode == NULL ) {
        RCt = XFS_RC ( rcExhausted );
    }
    else {
        RCt = XFSNodeInitVT (
                        & ( TheNode -> node),
                        Name,
                        ( const union XFSNode_vt * ) & _sDocNodeVT_v1
                        );
        if ( RCt == 0 ) {
            if ( Perm != NULL ) {
                RCt = XFS_StrDup ( Perm, & ( TheNode -> perm ) );
            }

            if ( RCt == 0 ) {
                RCt = XFSDocAddRef ( Doc );
                if ( RCt == 0 ) {
                    TheNode -> doc = Doc;

                    TheNode -> flavor = Flavor;

                    * Node = & ( TheNode -> node );
                }
            }
        }
    }

    if ( RCt != 0 ) {
        if ( TheNode != NULL ) {
            XFSNodeDispose ( & ( TheNode -> node ) );
            TheNode = NULL;
        }
    }

/*
pLogMsg ( klogDebug, "XFSDocNodeMake ND[$(node)] NM[$(name)] Doc[$(doc)]", "node=%p,name=%s,doc=%s", ( void * ) TheNode, Name, Doc );
*/

    return RCt;
}   /* XFSDocNodeMakeWithFlavor () */