C++ (Cpp) conduit_node_as_int_ptr Beispiele

Beispiel #1

Datei: t_c_conduit_node.cpp Projekt: LLNL/conduit

//-----------------------------------------------------------------------------
TEST(c_conduit_node, simple_hier)
{
    int     a_val  = 10;
    int     b_val  = 20;
    double  c_val  = 30.0;
    
    conduit_node *n = conduit_node_create();
    
    conduit_node *a = conduit_node_fetch(n,"a");
    conduit_node *b = conduit_node_fetch(n,"b");
    conduit_node *c = conduit_node_fetch(n,"c");

    EXPECT_TRUE(conduit_node_is_root(n));
    
    EXPECT_FALSE(conduit_node_is_root(a));
    EXPECT_FALSE(conduit_node_is_root(b));
    EXPECT_FALSE(conduit_node_is_root(c));
    
    conduit_node_set_int(a,a_val);
    conduit_node_set_int(b,b_val);
    conduit_node_set_double(c,c_val);

    
    EXPECT_EQ(conduit_node_as_int(a),a_val);
    EXPECT_EQ(conduit_node_as_int(b),b_val);
    EXPECT_EQ(conduit_node_as_double(c),c_val);
        
    int    *a_ptr = conduit_node_as_int_ptr(a);
    int    *b_ptr = conduit_node_as_int_ptr(b);
    double *c_ptr = conduit_node_as_double_ptr(c);
    
    EXPECT_EQ(a_ptr[0],a_val);
    EXPECT_EQ(b_ptr[0],b_val);
    EXPECT_EQ(c_ptr[0],c_val);
    
    conduit_node_print(n);
    
    /// these are no-ops
    conduit_node_destroy(a);
    conduit_node_destroy(b);
    conduit_node_destroy(c);

    conduit_node_print(n);
    
    /// this actually deletes the node
    conduit_node_destroy(n);
}

Beispiel #2

Datei: t_c_conduit_node.cpp Projekt: LLNL/conduit

//-----------------------------------------------------------------------------
TEST(c_conduit_node, simple)
{
    conduit_node *n = conduit_node_create();
    
    EXPECT_TRUE(conduit_node_is_root(n));
    
    conduit_node_set_int(n,10);
    
    EXPECT_EQ(conduit_node_as_int(n),10);
    int *int_ptr = conduit_node_as_int_ptr(n);
    EXPECT_EQ(int_ptr[0],10);
    
    conduit_node_print(n);
    
    conduit_node_destroy(n);
}

Beispiel #3

Datei: t_c_conduit_node_set.cpp Projekt: DavidPoliakoff/conduit

//-----------------------------------------------------------------------------
TEST(c_conduit_node_set, set_native_int_ptr)
{
    char  icav[6] = {-2,-4,-8,-16,-32,-64};
    short isav[6] = {-2,-4,-8,-16,-32,-64};
    int   iiav[6] = {-2,-4,-8,-16,-32,-64};
    long  ilav[6] = {-2,-4,-8,-16,-32,-64};
        
    conduit_node *n = conduit_node_create();
    
    // using char* interface
    conduit_node_set_char_ptr(n,icav,6);
    conduit_node_print(n);

    char *icav_ptr = conduit_node_as_char_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(icav_ptr[i],icav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&icav_ptr[i],&icav[i]);
    }
    EXPECT_EQ(icav_ptr[5],-64);
    
    // using short* interface
    conduit_node_set_short_ptr(n,isav,6);
    conduit_node_print(n);
    
    short *isav_ptr = conduit_node_as_short_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(isav_ptr[i],isav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&isav_ptr[i],&isav[i]);
    }
    EXPECT_EQ(isav_ptr[5],-64);
    
    // using int* interface
    conduit_node_set_int_ptr(n,iiav,6);
    conduit_node_print(n);

    int *iiav_ptr = conduit_node_as_int_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(iiav_ptr[i],iiav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&iiav_ptr[i],&iiav[i]);
    }
    EXPECT_EQ(iiav_ptr[5],-64);
    
    // using long * interface
    conduit_node_set_long_ptr(n,ilav,6);
    conduit_node_print(n);
    
    long *ilav_ptr = conduit_node_as_long_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(ilav_ptr[i],ilav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&ilav_ptr[i],&ilav[i]);
    }
    EXPECT_EQ(ilav_ptr[5],-64);
    
    conduit_node_destroy(n);
}