LoadBodiesIntoSession.hpp File Reference

Go to the source code of this file.

Functions
void	ActivatePsMemory (bool inActivate)
void	ActivatePsSession (bool inActivate)
void	ActivatePsTraverse (bool inActivate)
void	EnumerateBodiesInSession ()
bool	IsPsMemoryActivated ()
bool	IsPsSessionActivated ()
bool	IsPsTraverseActivated ()
void	LoadAssemblyIntoPsSession (const Dtk_string &inInputFile)
void	LoadBodiesIntoPsSession (const Dtk_string &inXtFile)
void	LoadBodiesIntoPsSessionFromStream (const Dtk_tab< char > &inStream)
void	ReceiveBodiesIntoCurrentPsSession (const Dtk_string &inXtFile)
void	ReceiveBodiesIntoCurrentPsSessionFromStream (const Dtk_tab< char > &inStream)
void	StartSharedPsSession ()
void	StopSharedPsSession ()

Function Documentation

ActivatePsMemory()

void ActivatePsMemory

(

bool

inActivate

)

{ s_psMemoryActivated   = inActivate; }

ActivatePsSession()

void ActivatePsSession

(

bool

inActivate

)

{ s_psSessionActivated  = inActivate; }

ActivatePsTraverse()

void ActivatePsTraverse

(

bool

inActivate

)

{ s_psTraverseActivated = inActivate; }

EnumerateBodiesInSession()

void EnumerateBodiesInSession

(

)

{
    PK_PARTITION_t partition = 0;
    PK_SESSION_ask_curr_partition( &partition );
 
    int nBodies = 0;
    PK_BODY_t* bodies = nullptr;
    PK_PARTITION_ask_bodies( partition, &nBodies, &bodies );
    cout << "Bodies in active partition: " << nBodies << endl;
 
    for( int i = 0; i < nBodies; ++i )
    {
        PK_BODY_t body = bodies[ i ];
 
        PK_BODY_type_t bodyType = 0;
        PK_BODY_ask_type( body, &bodyType );
 
        int nFaces = 0;
        PK_FACE_t* faces = nullptr;
        PK_ERROR_code_t fErr = PK_BODY_ask_faces( body, &nFaces, &faces );
 
        const char* typeName = "unknown";
        if     ( bodyType == PK_BODY_type_solid_c   ) typeName = "solid";
        else if( bodyType == PK_BODY_type_sheet_c   ) typeName = "sheet";
        else if( bodyType == PK_BODY_type_wire_c    ) typeName = "wire";
        else if( bodyType == PK_BODY_type_acorn_c   ) typeName = "acorn";
        else if( bodyType == PK_BODY_type_general_c ) typeName = "general";
 
        if( fErr == PK_ERROR_none )
        {
            cout << "  Body[" << i << "]  tag=" << body
                 << "  type=" << typeName
                 << "  faces=" << nFaces << endl;
            if( faces ) PK_MEMORY_free( faces );
        }
        else
        {
            cout << "  Body[" << i << "]  tag=" << body
                 << "  type=" << typeName
                 << "  PK_BODY_ask_faces error=" << fErr << endl;
        }
    }
 
    if( bodies ) PK_MEMORY_free( bodies );
}

IsPsMemoryActivated()

bool IsPsMemoryActivated

(

)

{ return s_psMemoryActivated;   }

IsPsSessionActivated()

bool IsPsSessionActivated

(

)

{ return s_psSessionActivated;  }

IsPsTraverseActivated()

bool IsPsTraverseActivated

(

)

{ return s_psTraverseActivated; }

LoadAssemblyIntoPsSession()

void LoadAssemblyIntoPsSession

(

const Dtk_string &

inInputFile

)

LoadBodiesIntoPsSession()

void LoadBodiesIntoPsSession

(

const Dtk_string &

inXtFile

)

{
    cout << "\n--- Parasolid session: loading \""
         << inXtFile.c_str() << "\" from disk ---" << endl;
 
    SetPSchema();
    StartPsSession();
 
    PK_PART_receive_o_t recvOpts;
    PK_PART_receive_o_m( recvOpts );
 
    int nParts  = 0;
    PK_PART_t* parts = nullptr;
    PK_ERROR_code_t pkErr = PK_PART_receive(
        inXtFile.c_str(), &recvOpts, &nParts, &parts );
 
    if( pkErr != PK_ERROR_none )
    {
        cout << "PK_PART_receive failed, error code: " << pkErr << endl;
        StopPsSession();
        return;
    }
    cout << "PK_PART_receive: " << nParts << " part(s) received." << endl;
 
    EnumerateBodiesInSession();
 
    if( parts ) PK_MEMORY_free( parts );
 
    StopPsSession();
    cout << "--- Parasolid session closed ---" << endl;
}

LoadBodiesIntoPsSessionFromStream()

void LoadBodiesIntoPsSessionFromStream

(

const Dtk_tab< char > &

inStream

)

{
    if( inStream.size() == 0 )
    {
        cout << "Warning: in-memory stream is empty, nothing to load." << endl;
        return;
    }
 
    cout << "\n--- Parasolid session: loading "
         << inStream.size() << " bytes from in-memory stream ---" << endl;
 
    SetPSchema();
    StartPsSession();
 
    // Map the Dtk_tab<char> buffer to a single PK_MEMORY_block_t.
    PK_MEMORY_block_t block;
    block.next    = nullptr;
    block.n_bytes = static_cast<size_t>( inStream.size() );
    block.bytes   = &inStream[ 0 ];
 
    PK_PART_receive_o_t recvOpts;
    PK_PART_receive_o_m( recvOpts );
 
    int nParts  = 0;
    PK_PART_t* parts = nullptr;
    PK_ERROR_code_t pkErr = PK_PART_receive_b( block, &recvOpts, &nParts, &parts );
 
    if( pkErr != PK_ERROR_none )
    {
        cout << "PK_PART_receive_b failed, error code: " << pkErr << endl;
        StopPsSession();
        return;
    }
    cout << "PK_PART_receive_b: " << nParts << " part(s) received." << endl;
 
    EnumerateBodiesInSession();
 
    if( parts ) PK_MEMORY_free( parts );
 
    StopPsSession();
    cout << "--- Parasolid session closed ---" << endl;
}

ReceiveBodiesIntoCurrentPsSession()

void ReceiveBodiesIntoCurrentPsSession

(

const Dtk_string &

inXtFile

)

{
    cout << "\n--- Receiving \""
         << inXtFile.c_str()
         << "\" into existing Parasolid session ---" << endl;
 
    PK_PART_receive_o_t recvOpts;
    PK_PART_receive_o_m( recvOpts );
 
    int nParts  = 0;
    PK_PART_t* parts = nullptr;
    PK_ERROR_code_t pkErr = PK_PART_receive(
        inXtFile.c_str(), &recvOpts, &nParts, &parts );
 
    if( pkErr != PK_ERROR_none )
    {
        cout << "PK_PART_receive failed, error code: " << pkErr << endl;
        return;
    }
    cout << "PK_PART_receive: " << nParts << " part(s) received." << endl;
 
    if( parts ) PK_MEMORY_free( parts );
}

ReceiveBodiesIntoCurrentPsSessionFromStream()

void ReceiveBodiesIntoCurrentPsSessionFromStream

(

const Dtk_tab< char > &

inStream

)

{
    if( inStream.size() == 0 )
    {
        cout << "Warning: in-memory stream is empty, nothing to receive." << endl;
        return;
    }
 
    cout << "\n--- Receiving "
         << inStream.size()
         << " bytes from in-memory stream into existing Parasolid session ---" << endl;
 
    PK_MEMORY_block_t block;
    block.next    = nullptr;
    block.n_bytes = static_cast<size_t>( inStream.size() );
    block.bytes   = &inStream[ 0 ];
 
    PK_PART_receive_o_t recvOpts;
    PK_PART_receive_o_m( recvOpts );
 
    int nParts  = 0;
    PK_PART_t* parts = nullptr;
    PK_ERROR_code_t pkErr = PK_PART_receive_b( block, &recvOpts, &nParts, &parts );
 
    if( pkErr != PK_ERROR_none )
    {
        cout << "PK_PART_receive_b failed, error code: " << pkErr << endl;
        return;
    }
    cout << "PK_PART_receive_b: " << nParts << " part(s) received." << endl;
 
    if( parts ) PK_MEMORY_free( parts );
}

StartSharedPsSession()

void StartSharedPsSession

(

)

{ SetPSchema(); StartPsSession(); }

StopSharedPsSession()

void StopSharedPsSession

(

)

{ StopPsSession(); }