grin api rename

Author: andydiwenzhu

modules/graph/fragment/arrow_fragment.grin.h

@@ -318,7 +318,7 @@ class GRIN_ArrowFragment {
   void init(GRIN_PARTITIONED_GRAPH partitioned_graph, GRIN_PARTITION partition) {
     pg_ = partitioned_graph;
     partition_ = partition;
-    g_ = grin_get_local_graph_from_partition(pg_, partition_);
+    g_ = grin_get_local_graph_by_partition(pg_, partition_);
   }
 
   bool directed() const {
@@ -414,7 +414,7 @@ class GRIN_ArrowFragment {
   template <typename T>
   bool GetVertex(GRIN_VERTEX_TYPE label, T& oid, GRIN_VERTEX v) {
     if (GRIN_DATATYPE_ENUM<T>::value != grin_get_vertex_original_id_type(g_)) return false;
-    v = grin_get_vertex_from_original_id_by_type(g_, label, (GRIN_VERTEX_ORIGINAL_ID)(&oid));
+    v = grin_get_vertex_by_original_id_by_type(g_, label, (GRIN_VERTEX_ORIGINAL_ID)(&oid));
     return v != NULL;
   }
 
@@ -430,7 +430,7 @@ class GRIN_ArrowFragment {
 
 #ifdef GRIN_NATURAL_PARTITION_ID_TRAIT
   GRIN_PARTITION_ID GetPartition(GRIN_VERTEX u) const {
-    auto vref = grin_get_vertex_ref_for_vertex(g_, u);
+    auto vref = grin_get_vertex_ref_by_vertex(g_, u);
     auto partition = grin_get_master_partition_from_vertex_ref(g_, vref); 
     return grin_get_partition_id(pg_, partition);
   }
@@ -612,7 +612,7 @@ class GRIN_ArrowFragment {
           if (in_edge) {
             auto es = GetIncomingAdjList(*v, etype);
             for (auto& e : es) {
-              auto vref = grin_get_vertex_ref_for_vertex(g_, e.neighbor());
+              auto vref = grin_get_vertex_ref_by_vertex(g_, e.neighbor());
               auto p = grin_get_master_partition_from_vertex_ref(g_, vref);
 
               if (!grin_equal_partition(g_, p, partition_)) {
@@ -628,7 +628,7 @@ class GRIN_ArrowFragment {
           if (out_edge) {
             auto es = GetOutgoingAdjList(*v, etype);
             for (auto& e : es) {
-              auto vref = grin_get_vertex_ref_for_vertex(g_, e.neighbor());
+              auto vref = grin_get_vertex_ref_by_vertex(g_, e.neighbor());
               auto p = grin_get_master_partition_from_vertex_ref(g_, vref);
 
               if (!grin_equal_partition(g_, p, partition_)) {

modules/graph/grin/c/test.c

@@ -24,7 +24,7 @@ GRIN_GRAPH get_graph(int argc, char** argv) {
   GRIN_PARTITION_LIST local_partitions = grin_get_local_partition_list(pg);
   GRIN_PARTITION partition =
       grin_get_partition_from_list(pg, local_partitions, 0);
-  GRIN_GRAPH g = grin_get_local_graph_from_partition(pg, partition);
+  GRIN_GRAPH g = grin_get_local_graph_by_partition(pg, partition);
 #else
   GRIN_GRAPH g = grin_get_graph_from_storage(argc - 1, &(argv[1]));
 #endif
@@ -108,7 +108,7 @@ void test_property_type(int argc, char** argv) {
 #ifdef GRIN_TRAIT_NATURAL_ID_FOR_VERTEX_TYPE
     printf("vertex type id: %u\n", grin_get_vertex_type_id(g, vt));
     GRIN_VERTEX_TYPE vt1 =
-        grin_get_vertex_type_from_id(g, grin_get_vertex_type_id(g, vt));
+        grin_get_vertex_type_by_id(g, grin_get_vertex_type_id(g, vt));
     if (!grin_equal_vertex_type(g, vt, vt1)) {
       printf("vertex type id not match\n");
     }
@@ -170,18 +170,18 @@ void test_property_type(int argc, char** argv) {
 #ifdef GRIN_TRAIT_NATURAL_ID_FOR_EDGE_TYPE
     printf("edge type id: %u\n", grin_get_edge_type_id(g, et));
     GRIN_EDGE_TYPE et1 =
-        grin_get_edge_type_from_id(g, grin_get_edge_type_id(g, et));
+        grin_get_edge_type_by_id(g, grin_get_edge_type_id(g, et));
     if (!grin_equal_edge_type(g, et, et1)) {
       printf("edge type id not match\n");
     }
     grin_destroy_edge_type(g, et1);
 #endif
     // relation
-    GRIN_VERTEX_TYPE_LIST src_vtl = grin_get_src_types_from_edge_type(g, et);
+    GRIN_VERTEX_TYPE_LIST src_vtl = grin_get_src_types_by_edge_type(g, et);
     size_t src_vtl_size = grin_get_vertex_type_list_size(g, src_vtl);
     printf("source vertex type list size: %zu\n", src_vtl_size);
 
-    GRIN_VERTEX_TYPE_LIST dst_vtl = grin_get_dst_types_from_edge_type(g, et);
+    GRIN_VERTEX_TYPE_LIST dst_vtl = grin_get_dst_types_by_edge_type(g, et);
     size_t dst_vtl_size = grin_get_vertex_type_list_size(g, dst_vtl);
     printf("destination vertex type list size: %zu\n", dst_vtl_size);
 
@@ -310,7 +310,7 @@ void test_property_topology(int argc, char** argv) {
   GRIN_DATATYPE dt = grin_get_vertex_original_id_type(g);
   if (dt == Int64) {
     long int v0id = 4;
-    GRIN_VERTEX v0 = grin_get_vertex_from_original_id_by_type(g, vt, &v0id);
+    GRIN_VERTEX v0 = grin_get_vertex_by_original_id_by_type(g, vt, &v0id);
     if (v0 == GRIN_NULL_VERTEX) {
       printf("(Wrong) vertex of id %ld can not be found\n", v0id);
     } else {
@@ -420,14 +420,14 @@ void test_property_vertex_table(int argc, char** argv) {
       GRIN_ROW row = grin_get_row_from_vertex_property_table(g, vpt, v, vpl);
       for (size_t j = 0; j < vpl_size; ++j) {
         GRIN_VERTEX_PROPERTY vp = grin_get_vertex_property_from_list(g, vpl, j);
-        GRIN_VERTEX_TYPE vt1 = grin_get_vertex_property_vertex_type(g, vp);
+        GRIN_VERTEX_TYPE vt1 = grin_get_vertex_type_from_property(g, vp);
         if (!grin_equal_vertex_type(g, vt, vt1)) {
           printf("vertex type not match by property\n");
         }
         grin_destroy_vertex_type(g, vt1);
 #ifdef GRIN_TRAIT_NATURAL_ID_FOR_VERTEX_PROPERTY
         unsigned int id = grin_get_vertex_property_id(g, vt, vp);
-        GRIN_VERTEX_PROPERTY vp1 = grin_get_vertex_property_from_id(g, vt, id);
+        GRIN_VERTEX_PROPERTY vp1 = grin_get_vertex_property_by_id(g, vt, id);
         if (!grin_equal_vertex_property(g, vp, vp1)) {
           printf("vertex property not match by id\n");
         }
@@ -437,7 +437,7 @@ void test_property_vertex_table(int argc, char** argv) {
 #endif
 
 #ifdef GRIN_WITH_VERTEX_PROPERTY_NAME
-        const char* vp_name = grin_get_vertex_property_name(g, vp);
+        const char* vp_name = grin_get_vertex_property_name(g, vt, vp);
         GRIN_VERTEX_PROPERTY vp2 =
             grin_get_vertex_property_by_name(g, vt, vp_name);
         if (!grin_equal_vertex_property(g, vp, vp2)) {
@@ -449,7 +449,7 @@ void test_property_vertex_table(int argc, char** argv) {
         GRIN_DATATYPE dt = grin_get_vertex_property_data_type(g, vp);
         const void* pv =
             grin_get_value_from_vertex_property_table(g, vpt, v, vp);
-        if (grin_get_last_error_code() == GRIN_NO_ERROR) {
+        if (grin_get_last_error_code() == NO_ERROR) {
           printf("(Correct) no error\n");
         } else {
           printf("(Wrong) error code: %d\n", grin_get_last_error_code());
@@ -479,7 +479,7 @@ void test_property_vertex_table(int argc, char** argv) {
 
 #ifdef GRIN_TRAIT_NATURAL_ID_FOR_VERTEX_PROPERTY
     GRIN_VERTEX_PROPERTY vp3 =
-        grin_get_vertex_property_from_id(g, vt, vpl_size);
+        grin_get_vertex_property_by_id(g, vt, vpl_size);
     if (vp3 == GRIN_NULL_VERTEX_PROPERTY) {
       printf("(Correct) vertex property of id %zu does not exist\n", vpl_size);
     } else {
@@ -518,8 +518,8 @@ void test_property_vertex_table(int argc, char** argv) {
       for (size_t i = 0; i < vpl2_size; ++i) {
         GRIN_VERTEX_PROPERTY vp5 =
             grin_get_vertex_property_from_list(g, vpl2, i);
-        GRIN_VERTEX_TYPE vt5 = grin_get_vertex_property_vertex_type(g, vp5);
-        const char* vp5_name = grin_get_vertex_property_name(g, vp5);
+        GRIN_VERTEX_TYPE vt5 = grin_get_vertex_type_from_property(g, vp5);
+        const char* vp5_name = grin_get_vertex_property_name(g, vt5, vp5);
         const char* vt5_name = grin_get_vertex_type_name(g, vt5);
         printf("vertex type name: %s, vertex property name: %s\n", vt5_name,
                vp5_name);
@@ -588,18 +588,18 @@ void test_property_edge_table(int argc, char** argv) {
       GRIN_ROW row = grin_get_row_from_edge_property_table(g, ept, e, epl);
       for (size_t k = 0; k < epl_size; ++k) {
         GRIN_EDGE_PROPERTY ep = grin_get_edge_property_from_list(g, epl, k);
-        GRIN_EDGE_TYPE et2 = grin_get_edge_property_edge_type(g, ep);
+        GRIN_EDGE_TYPE et2 = grin_get_edge_type_from_property(g, ep);
         if (!grin_equal_edge_type(g, et, et2)) {
           printf("edge type does not match\n");
         }
         grin_destroy_edge_type(g, et2);
 
-        const char* ep_name = grin_get_edge_property_name(g, ep);
+        const char* ep_name = grin_get_edge_property_name(g, et, ep);
         printf("edge property name: %s\n", ep_name);
 
 #ifdef GRIN_TRAIT_NATURAL_ID_FOR_EDGE_PROPERTY
         unsigned int id = grin_get_edge_property_id(g, et, ep);
-        GRIN_EDGE_PROPERTY ep1 = grin_get_edge_property_from_id(g, et, id);
+        GRIN_EDGE_PROPERTY ep1 = grin_get_edge_property_by_id(g, et, id);
         if (!grin_equal_edge_property(g, ep, ep1)) {
           printf("edge property not match by id\n");
         }
@@ -644,11 +644,11 @@ void test_property_edge_table(int argc, char** argv) {
 
     for (size_t j = 0; j < epl_size; ++j) {
       GRIN_EDGE_PROPERTY ep = grin_get_edge_property_from_list(g, epl, j);
-      GRIN_EDGE_TYPE et1 = grin_get_edge_property_edge_type(g, ep);
+      GRIN_EDGE_TYPE et1 = grin_get_edge_type_from_property(g, ep);
       if (!grin_equal_edge_type(g, et, et1)) {
         printf("edge type does not match\n");
       }
-      const char* ep_name1 = grin_get_edge_property_name(g, ep);
+      const char* ep_name1 = grin_get_edge_property_name(g, et, ep);
       const char* et_name = grin_get_edge_type_name(g, et);
       printf("edge property name: %s, edge property type name: %s\n", ep_name1,
              et_name);
@@ -658,7 +658,7 @@ void test_property_edge_table(int argc, char** argv) {
       grin_destroy_name(g, et_name);
 
 #ifdef GRIN_WITH_EDGE_PROPERTY_NAME
-      const char* ep_name = grin_get_edge_property_name(g, ep);
+      const char* ep_name = grin_get_edge_property_name(g, et, ep);
       GRIN_EDGE_PROPERTY ep2 = grin_get_edge_property_by_name(g, et, ep_name);
       if (!grin_equal_edge_property(g, ep, ep2)) {
         printf("edge property not match by name\n");
@@ -669,7 +669,7 @@ void test_property_edge_table(int argc, char** argv) {
       grin_destroy_edge_property(g, ep);
     }
 #ifdef GRIN_TRAIT_NATURAL_ID_FOR_EDGE_PROPERTY
-    GRIN_EDGE_PROPERTY ep3 = grin_get_edge_property_from_id(g, et, epl_size);
+    GRIN_EDGE_PROPERTY ep3 = grin_get_edge_property_by_id(g, et, epl_size);
     if (ep3 == GRIN_NULL_EDGE_PROPERTY) {
       printf("(Correct) edge property of id %zu does not exist\n", epl_size);
     } else {
@@ -705,8 +705,8 @@ void test_property_edge_table(int argc, char** argv) {
       size_t epl2_size = grin_get_edge_property_list_size(g, epl2);
       for (size_t i = 0; i < epl2_size; ++i) {
         GRIN_EDGE_PROPERTY ep5 = grin_get_edge_property_from_list(g, epl2, i);
-        GRIN_EDGE_TYPE et5 = grin_get_edge_property_edge_type(g, ep5);
-        const char* ep5_name = grin_get_edge_property_name(g, ep5);
+        GRIN_EDGE_TYPE et5 = grin_get_edge_type_from_property(g, ep5);
+        const char* ep5_name = grin_get_edge_property_name(g, et5, ep5);
         const char* et5_name = grin_get_edge_type_name(g, et5);
         printf("edge type name: %s, edge property name: %s\n", et5_name,
                ep5_name);
@@ -751,7 +751,7 @@ void test_property_primary_key(int argc, char** argv) {
 
     for (size_t j = 0; j < vpl_size; ++j) {
       GRIN_VERTEX_PROPERTY vp = grin_get_vertex_property_from_list(g, vpl, j);
-      const char* vp_name = grin_get_vertex_property_name(g, vp);
+      const char* vp_name = grin_get_vertex_property_name(g, vt, vp);
       printf("primary key name: %s\n", vp_name);
       grin_destroy_name(g, vp_name);
       grin_destroy_vertex_property(g, vp);
@@ -802,7 +802,7 @@ void test_error_code(int argc, char** argv) {
   GRIN_VERTEX v = get_one_vertex(g);
 
   const void* value = grin_get_value_from_vertex_property_table(g, vpt, v, vp);
-  if (grin_get_last_error_code() == GRIN_INVALID_VALUE) {
+  if (grin_get_last_error_code() == INVALID_VALUE) {
     printf("(Correct) invalid value\n");
   } else {
     printf("(Wrong) error code: %d\n", grin_get_last_error_code());

modules/graph/grin/docs/README.md

@@ -31,11 +31,11 @@ The example demonstrates how to synchronize property values of vertices associat
 
 ```CPP
     void sync_property(GRIN_PARTITIONED_GRAPH partitioned_graph, GRIN_PARTITION partition, const char* edge_type_name, const char* vertex_property_name) {
-        GRIN_GRAPH g = grin_get_local_graph_from_partition(partitioned_graph, partition);  // get local graph of partition
+        GRIN_GRAPH g = grin_get_local_graph_by_partition(partitioned_graph, partition);  // get local graph of partition
 
         GRIN_EDGE_TYPE etype = grin_get_edge_type_by_name(g, edge_type_name);  // get edge type from name
-        GRIN_VERTEX_TYPE_LIST src_vtypes = grin_get_src_types_from_edge_type(g, etype);  // get related source vertex type list
-        GRIN_VERTEX_TYPE_LIST dst_vtypes = grin_get_dst_types_from_edge_type(g, etype);  // get related destination vertex type list
+        GRIN_VERTEX_TYPE_LIST src_vtypes = grin_get_src_types_by_edge_type(g, etype);  // get related source vertex type list
+        GRIN_VERTEX_TYPE_LIST dst_vtypes = grin_get_dst_types_by_edge_type(g, etype);  // get related destination vertex type list
 
         size_t src_vtypes_num = grin_get_vertex_type_list_size(g, src_vtypes);
         size_t dst_vtypes_num = grin_get_vertex_type_list_size(g, dst_vtypes);
@@ -76,7 +76,7 @@ The example demonstrates how to synchronize property values of vertices associat
                     GRIN_VERTEX u = grin_get_neighbor_from_adjacent_list(g, adj_list, k);  // get the dst vertex u
                     const void* value = grin_get_value_from_vertex_property_table(g, dst_vpt, u, dst_vp);  // get the property value of "features" of u
 
-                    GRIN_VERTEX_REF uref = grin_get_vertex_ref_for_vertex(g, u);  // get the reference of u that can be recoginized by other partitions
+                    GRIN_VERTEX_REF uref = grin_get_vertex_ref_by_vertex(g, u);  // get the reference of u that can be recoginized by other partitions
                     GRIN_PARTITION u_master_partition = grin_get_master_partition_from_vertex_ref(g, uref);  // get the master partition for u
 
                     send_value(u_master_partition, uref, dst_vp_dt, value);  // the value must be casted to the correct type based on dst_vp_dt before sending
@@ -297,7 +297,7 @@ be recognized in partitions other than the current partition where the instance
     ```CPP
         /* grin/partition/partition.h */
 
-        GRIN_VERTEX_REF grin_get_vertex_ref_for_vertex(GRIN_GRAPH, GRIN_VERTEX);
+        GRIN_VERTEX_REF grin_get_vertex_ref_by_vertex(GRIN_GRAPH, GRIN_VERTEX);
 
         const char* grin_serialize_vertex_ref(GRIN_GRAPH, GRIN_VERTEX_REF);
 
@@ -308,7 +308,7 @@ be recognized in partitions other than the current partition where the instance
 
         /* run.cc in machine 1 */
         {
-            auto vref = grin_get_vertex_ref_for_vertex(g, v);  // get v's vertex ref which can be recgonized in machine 2
+            auto vref = grin_get_vertex_ref_by_vertex(g, v);  // get v's vertex ref which can be recgonized in machine 2
 
             const char* msg = grin_serialize_vertex_ref(g, vref);  // serialize into a message
 

modules/graph/grin/include

@@ -55,10 +55,10 @@ typedef enum {
 
 /// Enumerates the error codes of grin
 typedef enum {
-  GRIN_NO_ERROR = 0,               ///< success
-  GRIN_UNKNOWN_ERROR = 1,         ///< unknown error
-  GRIN_INVALID_VALUE = 2,         ///< invalid value
-  GRIN_UNKNOWN_DATATYPE = 3,      ///< unknown datatype
+  NO_ERROR = 0,               ///< success
+  UNKNOWN_ERROR = 1,         ///< unknown error
+  INVALID_VALUE = 2,         ///< invalid value
+  UNKNOWN_DATATYPE = 3,      ///< unknown datatype
 } GRIN_ERROR_CODE;
 
 /* Section 1: Toplogy */