RecordProxy

class numpy::RecordProxy

numpy C++ class.

Example

#include <numpy/np_ndarray.h>
using namespace numpy;

// Use RecordProxy
RecordProxy obj;
// ... operations ...

Constructors

Signature	Location	Example
RecordProxy(StructuredArray \*array, const std::vector<size_t>&indices)	NP_RECARRAY.H:41

Operators

Signature	Return Type	Location	Example
RecordArrayFieldProxy operator[](const std::string &field_name)	RecordArrayFieldProxy	NP_RECARRAY.H:44

Indexing / Selection

Signature	Return Type	Location	Example
T getField(const std::string &field_name)	T	NP_RECARRAY.H:51	View
StructuredRecord getRecord()	StructuredRecord	NP_RECARRAY.H:61	View

Other Methods

Signature	Return Type	Location	Example
void setField(const std::string &field_name, const T &value)	void	NP_RECARRAY.H:56	View
void setRecord(const StructuredRecord &record)	void	NP_RECARRAY.H:65

Code Examples

The following examples are extracted from the test suite.

getField (np_test_2_all.cpp:18700)

    void np_test_io_extensions_recfromcsv_dtype_detection() {
      std::cout << "========= recfromcsv: automatic dtype detection =======================";

      create_csv_file("test_dtypes.csv");

      auto data = numpy::io::recfromcsv(csv_test_dir + "test_dtypes.csv");
      auto dtype = data.getDType();

      // Verify string field detected
      auto name_dtype = dtype.getField("name").dtype;
      if (name_dtype != numpy::DType::STR32 && name_dtype != numpy::DType::STR16 &&
        name_dtype != numpy::DType::STR8 && name_dtype != numpy::DType::STR64) {
        std::cout << "  [FAIL] : Expected STRING type for name field" << std::endl;
        throw std::runtime_error("np_test_io_extensions_recfromcsv_dtype_detection failed: wrong name dtype");
      }

      // Verify integer field detected
      auto age_dtype = dtype.getField("age").dtype;
      if (age_dtype != numpy::DType::INT64 && age_dtype != numpy::DType::INT32) {
        std::cout << "  [FAIL] : Expected INT type for age field";

getRecord (np_test_1_all.cpp:26346)

      };
      auto dtype = std::make_shared<numpy::StructuredDType>(fields);
      numpy::RecordArray arr(dtype, { 2 });

      arr.setFieldValue({ 0 }, "id", numpy::int32(1));
      arr.setFieldValue({ 0 }, "value", numpy::float64(10.5));
      arr.setFieldValue({ 1 }, "id", numpy::int32(2));
      arr.setFieldValue({ 1 }, "value", numpy::float64(20.5));

      // Test basic comparison operations (indirectly tests createComparisonValue)
      auto rec0 = arr.getRecord({ 0 });
      auto rec1 = arr.getRecord({ 1 });

      // Verify records are different (basic comparison test)
      bool passed = true;  // If we can get records without error, comparison values work

      if (!passed) {
        std::cout << "  [FAIL] : in np_test_recarray_createComparisonValue() : Create comparison value failed";
        throw std::runtime_error("np_test_recarray_createComparisonValue failed");
      }

setField (np_test_5_all.cpp:8457)

    std::cout << "========= StructuredArray::toString() basic =======================";

    std::vector<numpy::StructuredField> fields = {
        {"name", numpy::DType::STR_, 0, 10},
        {"age", numpy::DType::INT32, 10, 4}
    };

    auto dtype = std::make_shared<numpy::StructuredDType>(fields);
    numpy::StructuredArray arr(dtype, std::vector<size_t>{2});

    arr.setField({ 0 }, "name", numpy::StructuredValue(std::string("Alice")));
    arr.setField({ 0 }, "age", numpy::StructuredValue(static_cast<int32_t>(30)));
    arr.setField({ 1 }, "name", numpy::StructuredValue(std::string("Bob")));
    arr.setField({ 1 }, "age", numpy::StructuredValue(static_cast<int32_t>(25)));

    std::string result = arr.toString();

    // std::cout << "Result:\n" << result << std::endl;

    verify_not_empty(result, "StructuredArray toString()");