C++ (Cpp) Call1 Examples

Example #1

File: unwind_benchmarks.cpp Project: MoKee/android_system_core

static void BM_cached_unwind(benchmark::State& state) {
  auto process_memory = unwindstack::Memory::CreateProcessMemoryCached(getpid());
  unwindstack::LocalMaps maps;
  if (!maps.Parse()) {
    state.SkipWithError("Failed to parse local maps.");
  }

  for (auto _ : state) {
    benchmark::DoNotOptimize(Call1(process_memory, &maps));
  }
}

Example #2

File: PeachComTest.cpp Project: asudhak/peachfuzz-code

STDMETHODIMP CPeachComTest::Method3(BSTR str)
{
	// TODO: Add your implementation code here
	wprintf(L"CPeachComTest::Method3(%s)\n", str);

	if (wcslen(str) > 50)
	{
		char buff[10];
		wprintf(L"In Call1");
		Call1(buff);
	}

	return S_OK;
}

Example #3

File: aperture_mex.cpp Project: munthe/SASB

extern bool aperture_bft_set(mxArray *plhs[], const mxArray* mx_handle,
                             const mxArray* mx_data, const size_t type) {

  const int n_odim = 1;
  const float_type* data_vec;
  const bool* p_b = NULL;

  mwSize o_dims[n_odim];

	//  mwSize n_elements, length;
  size_t n_elements, length;

  Aperture* p_aperture = NULL;
  bool* p_blhs = NULL;
  char stype[256];

  Call(mxIsPointer, (mx_handle));

  if (type < 7)
    Call(mxIsRealFloat, (mx_data));

  p_aperture = &(get_object<Aperture>(mx_handle));

  o_dims[0] = mwSize(1);

  Call(plhs[0] = mxCreateLogicalArray,
       (n_odim, (const mwSize*)o_dims));

  n_elements = (mwSize) mxGetM(mx_data);
  
  data_vec = ((const float_type *) mxGetData(mx_data));

  switch (type) {
  case 0:
    // Positions
    Call1(mxCheckDimensions, (mx_data, 2, n_elements, 3),
          "Positions must be 3D array");
    length = (size_t)3*n_elements;
    Call1(p_aperture->setPositions, (data_vec, length), "Incompatible size");
    p_aperture->data->m_type = Aperture::custom;
    break;
  case 1:
    // Focus
    if ((mxGetM(mx_data)==0) && (mxGetN(mx_data)==0)) {
      data_vec = NULL;
    }
    else {
      Call1(mxCheckDimensions, (mx_data, 2, 1, 3), "Positions must be 3D");
    }
    p_aperture->setFocus(data_vec);
    break;
  case 2:
    // Center focus
    Call1(mxCheckDimensions, (mx_data, 2, n_elements, 3),
          "Positions must be 3D");
    p_aperture->setCenterFocus(data_vec, n_elements);
    break;
  case 3:
    // fs
    Call1(mxIsScalarFloat, (mx_data), "fs must be scalar float");
    Aperture::_fs = *((const float_type*) mxGetData(mx_data));
    break;
  case 6:
    // c
    Call1(mxIsScalarFloat, (mx_data), "c must be scalar float");
    Aperture::_c = *((const float_type*) mxGetData(mx_data));
    break;
  case 4:
    // f0
    Call1(mxIsScalarFloat, (mx_data), "f0 must be scalar float");
    Aperture::_f0 = *((const float_type*) mxGetData(mx_data));
  case 5:
    // Delays
    if ((mxGetM(mx_data)==0) && (mxGetN(mx_data)==0)) {
      data_vec = NULL;
    }
    else {
      Call1(mxCheckDimensions, (mx_data, 2, p_aperture->n_elements(), 1),
            "Receive delays must match number of elements");
    }
    p_aperture->setDelays(data_vec);
    break;
  case 7:
    // Aperture type
    Call(mxIsChar, (mx_data));
    Call(mxu_fixed_string, (stype, 256, mx_data, "1st argument"));
    if (!strcmp(stype,"custom"))
      p_aperture->data->m_type = Aperture::custom;
    else if (!strcmp(stype,"linear_array"))
      p_aperture->data->m_type = Aperture::linear_array;
    else if (!strcmp(stype,"convex_array"))
      p_aperture->data->m_type = Aperture::convex_array;
    else {
      Fail("Unknown type");
    }
    break;
  case 8:
    // PP-wave on/off
    Call(mxIsLogical, (mx_data));
    p_b = ((const bool*)  mxGetData(mx_data));
    p_aperture->data->m_ppwave = *p_b;
    break;
	case 9:
		// Orientation
    Call1(mxCheckDimensions, (mx_data, 2, n_elements, 3),
          "Orientations must be 3D Euler angles");
    p_aperture->setOrientation(data_vec, n_elements);
    break;
  default:
    break;
  }
  
  p_blhs = ((bool*) mxGetData(plhs[0]));
  *p_blhs = true;
  return true;
}