コード例 #1
0
ファイル: image_mgr_lua.cpp プロジェクト: lrh/SFGE
  Image* image = &ImageManager::GetInstance().GetImage(key);
  *(void**)(lua_newuserdata(L, sizeof(void*))) = image;
#endif

  luaL_getmetatable(L, LuaImage::className_);
  lua_setmetatable(L, -2);

  return 1;
}

#define METHOD(class, name) { #name, class::name }

const char* LuaImage::className_ = "Image";
const luaL_reg LuaImage::methods_[] = 
{
  METHOD(LuaImage, SetSmooth),
  {0, 0},
};

int LuaImage::SetSmooth(lua_State* L)
{
  assert(lua_gettop(L) == 2);

#if 1
  Image* image = *static_cast<Image**>(luaL_checkudata(L, 1, LuaImage::className_));
#else // lua_unboxpointer
  Image* image = (Image*)(*(void **)(lua_touserdata(L, 1)));
#endif
  
  bool smooth = lua_toboolean(L, 2);
  image->SetSmooth(smooth);
コード例 #2
0
ファイル: config.c プロジェクト: cboos/pygit2
        return NULL;

    err = git_config_set_multivar(self->config, name, regex, value);
    if (err < 0) {
        if (err == GIT_ENOTFOUND)
            Error_set(err);
        else
            PyErr_SetNone(PyExc_TypeError);
        return NULL;
    }

    Py_RETURN_NONE;
}

PyMethodDef Config_methods[] = {
    METHOD(Config, get_system_config, METH_NOARGS | METH_STATIC),
    METHOD(Config, get_global_config, METH_NOARGS | METH_STATIC),
    METHOD(Config, foreach, METH_VARARGS),
    METHOD(Config, add_file, METH_VARARGS | METH_KEYWORDS),
    METHOD(Config, get_multivar, METH_VARARGS),
    METHOD(Config, set_multivar, METH_VARARGS),
    {NULL}
};

PySequenceMethods Config_as_sequence = {
    0,                          /* sq_length */
    0,                          /* sq_concat */
    0,                          /* sq_repeat */
    0,                          /* sq_item */
    0,                          /* sq_slice */
    0,                          /* sq_ass_item */
コード例 #3
0
ファイル: repository.c プロジェクト: cjwatson/pygit2
PyObject *
Repository_expand_id(Repository *self, PyObject *py_hex)
{
    git_oid oid;
    int err;

    err = py_oid_to_git_oid_expand(self->repo, py_hex, &oid);
    if (err < 0)
        return NULL;

    return git_oid_to_python(&oid);
}

PyMethodDef Repository_methods[] = {
    METHOD(Repository, create_blob, METH_VARARGS),
    METHOD(Repository, create_blob_fromworkdir, METH_VARARGS),
    METHOD(Repository, create_blob_fromdisk, METH_VARARGS),
    METHOD(Repository, create_commit, METH_VARARGS),
    METHOD(Repository, create_tag, METH_VARARGS),
    METHOD(Repository, TreeBuilder, METH_VARARGS),
    METHOD(Repository, walk, METH_VARARGS),
    METHOD(Repository, merge_base, METH_VARARGS),
    METHOD(Repository, merge_analysis, METH_O),
    METHOD(Repository, merge, METH_O),
    METHOD(Repository, cherrypick, METH_O),
    METHOD(Repository, read, METH_O),
    METHOD(Repository, write, METH_VARARGS),
    METHOD(Repository, create_reference_direct, METH_VARARGS),
    METHOD(Repository, create_reference_symbolic, METH_VARARGS),
    METHOD(Repository, listall_references, METH_NOARGS),
コード例 #4
0
ファイル: repository.c プロジェクト: victorgp/pygit2_dup
    len = py_oid_to_git_oid(py_oid, &oid);
    if (len == 0)
        return NULL;

    err = git_object_lookup_prefix(&target, self->repo, &oid, len,
                                   GIT_OBJ_ANY);
    err = err < 0 ? err : git_reset(self->repo, target, reset_type);
    git_object_free(target);
    if (err < 0)
        return Error_set_oid(err, &oid, len);
    Py_RETURN_NONE;
}

PyMethodDef Repository_methods[] = {
    METHOD(Repository, create_blob, METH_VARARGS),
    METHOD(Repository, create_blob_fromworkdir, METH_VARARGS),
    METHOD(Repository, create_blob_fromdisk, METH_VARARGS),
    METHOD(Repository, create_commit, METH_VARARGS),
    METHOD(Repository, create_tag, METH_VARARGS),
    METHOD(Repository, TreeBuilder, METH_VARARGS),
    METHOD(Repository, walk, METH_VARARGS),
    METHOD(Repository, merge_base, METH_VARARGS),
    METHOD(Repository, merge, METH_O),
    METHOD(Repository, read, METH_O),
    METHOD(Repository, write, METH_VARARGS),
    METHOD(Repository, create_reference_direct, METH_VARARGS),
    METHOD(Repository, create_reference_symbolic, METH_VARARGS),
    METHOD(Repository, listall_references, METH_NOARGS),
    METHOD(Repository, lookup_reference, METH_O),
    METHOD(Repository, revparse_single, METH_O),
コード例 #5
0
ファイル: mext_methods.c プロジェクト: artfwo/serialosc
void
osc_unregister_methods(sosc_state_t *state)
{
	char *prefix, *cmd_buf;
	lo_server srv;

	prefix = state->config.app.osc_prefix;
	srv = state->server;

#define UNREGISTER(typetags) \
	lo_server_del_method(srv, cmd_buf, typetags)

	METHOD("grid/led/set")
		UNREGISTER("iii");

	METHOD("grid/led/all")
		UNREGISTER("i");

	METHOD("grid/led/map")
		UNREGISTER("iiiiiiiiii");

	METHOD("grid/led/col")
		UNREGISTER(NULL);

	METHOD("grid/led/row")
		UNREGISTER(NULL);

	METHOD("grid/led/intensity")
		UNREGISTER("i");

	METHOD("grid/led/level/set")
		UNREGISTER("iii");

	METHOD("grid/led/level/all")
		UNREGISTER("i");

	METHOD("grid/led/level/map")
		UNREGISTER("ii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii");

	METHOD("grid/led/level/col")
		UNREGISTER(NULL);

	METHOD("grid/led/level/row")
		UNREGISTER(NULL);

	METHOD("ring/set")
		UNREGISTER("iii");

	METHOD("ring/all")
		UNREGISTER("ii");

	METHOD("ring/map")
		UNREGISTER("i"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii"
		           "iiiiiiii");

	METHOD("ring/range")
		UNREGISTER("iiii");

	METHOD("tilt/set")
		UNREGISTER("ii");

#undef UNREGISTER
}
コード例 #6
0
ファイル: walker.c プロジェクト: gabrielfalcao/pygit2
    err = git_commit_lookup(&commit, self->repo->repo, &oid);
    if (err < 0)
        return Error_set(err);

    py_commit = PyObject_New(Commit, &CommitType);
    if (py_commit) {
        py_commit->commit = commit;
        Py_INCREF(self->repo);
        py_commit->repo = self->repo;
    }
    return (PyObject*)py_commit;
}

PyMethodDef Walker_methods[] = {
    METHOD(Walker, hide, METH_O),
    METHOD(Walker, push, METH_O),
    METHOD(Walker, reset, METH_NOARGS),
    METHOD(Walker, sort, METH_O),
    {NULL}
};


PyDoc_STRVAR(Walker__doc__, "Revision walker.");

PyTypeObject WalkerType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "_pygit2.Walker",                          /* tp_name           */
    sizeof(Walker),                            /* tp_basicsize      */
    0,                                         /* tp_itemsize       */
    (destructor)Walker_dealloc,                /* tp_dealloc        */
コード例 #7
0
ファイル: VMMethod.c プロジェクト: SOM-st/CSOM
VTABLE(VMMethod)* VMMethod_vtable(void) {
    if(! VMMethod_vtable_inited) {
        *((VTABLE(VMArray)*)&_VMMethod_vtable) = *VMArray_vtable();
        
        ASSIGN_TRAIT(VMInvokable, VMMethod);

        _VMMethod_vtable.init = METHOD(VMMethod, init);        
        _VMMethod_vtable.get_number_of_locals =
            METHOD(VMMethod, get_number_of_locals);
        _VMMethod_vtable.get_maximum_number_of_stack_elements =
            METHOD(VMMethod, get_maximum_number_of_stack_elements);
        _VMMethod_vtable._get_offset = METHOD(VMMethod, _get_offset);
        _VMMethod_vtable.set_holder_all = METHOD(VMMethod, set_holder_all);
        _VMMethod_vtable.get_constant = METHOD(VMMethod, get_constant);
        _VMMethod_vtable.get_number_of_arguments =
            METHOD(VMMethod, get_number_of_arguments);
        _VMMethod_vtable.get_number_of_bytecodes =
            METHOD(VMMethod, get_number_of_bytecodes);
        _VMMethod_vtable.get_bytecode = METHOD(VMMethod, get_bytecode);
        _VMMethod_vtable.set_bytecode = METHOD(VMMethod, set_bytecode);
        _VMMethod_vtable.invoke_method = METHOD(VMMethod, invoke_method);
        
        _VMMethod_vtable.mark_references = 
            METHOD(VMMethod, mark_references);

        VMMethod_vtable_inited = true;
    }
コード例 #8
0
ファイル: spxscaler.cpp プロジェクト: nicolaje/reliable-slam
const char* SPxScaler::getName() const
{
   METHOD( "SPxScaler::getName()" );

   return m_name;
}
コード例 #9
0
ファイル: spxscaler.cpp プロジェクト: nicolaje/reliable-slam
void SPxScaler::setOrder(bool colFirst)
{
   METHOD( "SPxScaler::setOrder()" );

   m_colFirst = colFirst;
}
コード例 #10
0
ファイル: taskbar.c プロジェクト: doolse/wingsos
void updateitem(msgpass * msg) {
  int code = msg->code;
  int getnum = msg->getnum;
  void * mainwin = msg->mainwin;
  item * curitem = itemhead;
  void * clickbmpclass;
  int region;
  RegInfo props;
  int size,position;

  switch(code) {
    case TSKM_KILLED:
      if(!curitem)
        break;
      while(curitem->mainwin != mainwin) {
        curitem = curitem->next;
        //printf("looking for item to kill\n");
      }
      JCntRemove(taskbar,curitem->icon);
      JWKill(curitem->icon);
      itemhead = remQueue(itemhead,curitem);
      sendChan(appchannel,REFRESH);
      resizebar(-1);
    break;    

    case TSKM_NEWITEM:
      curitem = malloc(sizeof(item));

      region = ((JMan *)mainwin)->Region;
      JRegInfo(region,&props);

      if(props.metadata) {
        curitem->title     = props.metadata->title;
        curitem->launchstr = props.metadata->launchpath;
        if(props.metadata->icon) {
          curitem->iconbmp = props.metadata->icon;
        } else {
          curitem->iconbmp = malloc(36);
          memcpy(curitem->iconbmp,ICO_APP_DFL,36);
        }
      } else {
        curitem->title     = strdup("Application");
        curitem->launchstr = strdup(""); //something that can be free()'d
        curitem->iconbmp = malloc(36);
        memcpy(curitem->iconbmp,ICO_APP_DFL,36);
      }

      clickbmpclass = JSubclass(&JBmpClass,-1,
                                  METHOD(MJW, Button), changefocus,
                                  -1);
      curitem->icon = JNew(clickbmpclass);
      JBmpInit(curitem->icon,16,16,curitem->iconbmp);
      ((JW*)curitem->icon)->Sense |= WEV_Button;
      JWSetData(curitem->icon,curitem);

      curitem->status  = getnum;
      curitem->mainwin = mainwin;
      
      itemhead = addQueueB(itemhead,itemhead,curitem);

      resizebar(1);
      JCntAdd(taskbar,curitem->icon);
      JWinShow(curitem->icon);
      sendChan(appchannel,REFRESH);

      //printf("taskbar: new item, %d\n",getnum);

      if(getnum == TSKM_INFOCUS)
        sendChan(appchannel,SETCOL,curitem->icon,COL_FOC);
      else if(getnum == TSKM_INBLUR)
        sendChan(appchannel,SETCOL,curitem->icon,COL_NFOC);
      else
        sendChan(appchannel,SETCOL,curitem->icon,COL_MIN);
    break;

    case TSKM_INFOCUS:
      if(!curitem)
        break;
      while(curitem->mainwin != mainwin) {
        curitem = curitem->next;
        //printf("finding first item (infocus)\n");
      }
      while(curitem->next->mainwin != mainwin) {
        //printf("I think this is the bad loop.\n");
        curitem = curitem->next;
        if(curitem->status == TSKM_INFOCUS) {
          sendChan(appchannel,SETCOL,curitem->icon,COL_NFOC);
          curitem->status = TSKM_INBLUR;
        }
      }
      curitem = curitem->next;
      sendChan(appchannel,SETCOL,curitem->icon,COL_FOC);
      curitem->status = TSKM_INFOCUS;
    break;

    case TSKM_MINIMIZED:
      if(!curitem)
        break;
      while(curitem->mainwin != mainwin) {
        curitem = curitem->next;
        //printf("finding first item (minimized)\n");
      }
      sendChan(appchannel,SETCOL,curitem->icon,COL_MIN);
      curitem->status = TSKM_MINIMIZED;
    break;
  }
}
コード例 #11
0
ファイル: spxscaler.cpp プロジェクト: nicolaje/reliable-slam
/** This function is used by computeScaleVecs and has to be overridden.
 */
Real SPxScaler::computeScale(Real /*mini*/, Real /*maxi*/) const
{
   METHOD( "SPxScaler::computeScale" );

   return 1.0;
}
コード例 #12
0
ファイル: note.c プロジェクト: Rekii008/pygit2
    return to_unicode(git_note_message(self->note), NULL, NULL);
}


static void
Note_dealloc(Note *self)
{
    Py_CLEAR(self->repo);
    free(self->annotated_id);
    git_note_free(self->note);
    PyObject_Del(self);
}


PyMethodDef Note_methods[] = {
    METHOD(Note, remove, METH_VARARGS),
    {NULL}
};

PyMemberDef Note_members[] = {
    MEMBER(Note, annotated_id, T_STRING, "id of the annotated object."),
    {NULL}
};

PyGetSetDef Note_getseters[] = {
    GETTER(Note, message),
    GETTER(Note, oid),
    {NULL}
};

PyDoc_STRVAR(Note__doc__, "Note object.");
コード例 #13
0
void SPxBasis::Desc::reSize(int rowDim, int colDim)
{
   METHOD( "SPxBasis::Desc::reSize()" );
   rowstat.reSize(rowDim);
   colstat.reSize(colDim);
}
コード例 #14
0
ファイル: spxwritestate.cpp プロジェクト: aimanqais/gerardus
bool SPxSolver::writeState(
   const char*    filename,
   const NameSet* rowNames,
   const NameSet* colNames ) const
{
   METHOD( "SPxSolver::writeState()" );

   std::string ofname;
   std::ofstream ofs;

   // write parameter settings
   ofname = std::string(filename) + ".set";
   ofs.open(ofname.c_str());
   if (!ofs)
      return false;

   std::stringstream table, commandline;
   table
      << "Delta            = " << std::setw(8) << delta()
      << std::endl
      << "Epsilon Zero     = " << std::setw(8) << Param::epsilon()
      << std::endl
      << "Epsilon Factor   = " << std::setw(8) << Param::epsilonFactorization()
      << std::endl
      << "Epsilon Update   = " << std::setw(8) << Param::epsilonUpdate()
      << std::endl
      << "Verbosity        = " << std::setw(8) << Param::verbose()
      << std::endl << std::endl
      << "Algorithm        = " << (type() == SPxSolver::ENTER ? "Entering" : "Leaving")
      << std::endl
      << "Representation   = " << (rep() == SPxSolver::ROW ? "Row" : "Column")
      << std::endl
      << "Update           = " << slinSolver()->getName()
      << std::endl
      << "Pricer           = " << pricer()->getName()
#ifdef PARTIAL_PRICING
      << " (partial, size = " << MAX_PRICING_CANDIDATES << ")"
#endif
      << std::endl
      << "Starter          = " << ((starter() == 0) ? "no" : starter()->getName())
      << std::endl
      << "Ratiotest        = " << ratiotester()->getName()
      << std::endl << std::endl;

   commandline
      << "bin/soplex -g0 -s0"
      << " -f" << feastol()
      << " -o" << opttol()
      << (type() == SPxSolver::ENTER ? " -e" : "")
      << (rep()  == SPxSolver::ROW   ? " -r" : "")
      << (!strcmp(slinSolver()->getName(), "SLU-Eta") ? " -i" : "");
   if (!strcmp(pricer()->getName(), "Dantzig"))
      commandline << " -p0";
   else if (!strcmp(pricer()->getName(), "ParMult"))
      commandline << " -p1";
   else if (!strcmp(pricer()->getName(), "Devex"))
      commandline << " -p2";
   else if (!strcmp(pricer()->getName(), "Hybrid"))
      commandline << " -p3";
   else if (!strcmp(pricer()->getName(), "Steep"))
      commandline << " -p4";
   else if (!strcmp(pricer()->getName(), "Weight"))
      commandline << " -p5";
   else if (!strcmp(pricer()->getName(), "SteepEx"))
      commandline << " -p6";
   if (starter() != 0)
   {
      if (!strcmp(starter()->getName(), "Weight"))
         commandline << " -s1";
      else if (!strcmp(starter()->getName(), "Sum"))
         commandline << " -s2";
      else if (!strcmp(starter()->getName(), "Vector"))
         commandline << " -s3";
   }
   if (!strcmp(ratiotester()->getName(), "Default"))
      commandline << " -t0";
   else if (!strcmp(ratiotester()->getName(), "Harris"))
      commandline << " -t1";
   else if (!strcmp(ratiotester()->getName(), "Fast"))
      commandline << " -t2";
   else if (!strcmp(ratiotester()->getName(), "Bound Flipping"))
      commandline << " -t3";
   commandline  << " -br " << filename << ".mps " << filename << ".bas";
   ofs << "SoPlex Parameters:\n\n"  << table.str() << "Command line     > " << commandline.str();
   ofs.close();

   // write LP
   ofname = std::string(filename) + ".mps";
   ofs.open(ofname.c_str());
   if (!ofs)
      return false;

   writeMPS(ofs, rowNames, colNames, NULL);
   ofs.close();

   // write basis
   ofname = std::string(filename) + ".bas";
   return writeBasisFile(ofname.c_str(), rowNames, colNames);
}
コード例 #15
0
void CParamTooltipCtrl::AddMethod(const CString& sMethod, const vector<CString>& setParams)
{
	m_setMethods.push_back(METHOD(sMethod, setParams));
	m_nCurParam = 0;
}
コード例 #16
0
ファイル: spxscaler.cpp プロジェクト: nicolaje/reliable-slam
void SPxScaler::setBoth(bool both)
{
   METHOD( "SPxScaler::setBoth()" );

   m_doBoth = both;
}
コード例 #17
0
ファイル: diff.c プロジェクト: CODECOMMUNITY/pygit2
    if (!(self->flags & GIT_DIFF_FLAG_NOT_BINARY) &&
            (self->flags & GIT_DIFF_FLAG_BINARY))
        Py_RETURN_TRUE;
    Py_RETURN_FALSE;
}

static void
DiffDelta_dealloc(DiffDelta *self)
{
    Py_CLEAR(self->old_file);
    Py_CLEAR(self->new_file);
    PyObject_Del(self);
}

static PyMethodDef DiffDelta_methods[] = {
    METHOD(DiffDelta, status_char, METH_NOARGS),
    {NULL}
};

PyMemberDef DiffDelta_members[] = {
    MEMBER(DiffDelta, status, T_UINT, "A GIT_DELTA_* constant."),
    MEMBER(DiffDelta, flags, T_UINT, "Combination of GIT_DIFF_FLAG_* flags."),
    MEMBER(DiffDelta, similarity, T_USHORT, "For renamed and copied."),
    MEMBER(DiffDelta, nfiles, T_USHORT, "Number of files in the delta."),
    MEMBER(DiffDelta, old_file, T_OBJECT, "\"from\" side of the diff."),
    MEMBER(DiffDelta, new_file, T_OBJECT, "\"to\" side of the diff."),
    {NULL}
};

PyGetSetDef DiffDelta_getseters[] = {
    GETTER(DiffDelta, is_binary),
コード例 #18
0
void mexFunction
(
    int nargout,
    mxArray *pargout [ ],
    int nargin,
    const mxArray *pargin [ ]
)
{

    bool malloc_debug = GB_mx_get_global (true) ;
    GrB_Matrix A = NULL ;
    void *Y = NULL ;
    void *Xtemp = NULL ;
    void *X = NULL ;
    GrB_Index nvals = 0 ;

    // check inputs
    GB_WHERE (USAGE) ;
    if (nargout > 3 || nargin < 1 || nargin > 2)
    {
        mexErrMsgTxt ("Usage: " USAGE) ;
    }

    #define GET_DEEP_COPY ;
    #define FREE_DEEP_COPY ;

    // get A (shallow copy)
    A = GB_mx_mxArray_to_Matrix (pargin [0], "A input", false, true) ;
    if (A == NULL)
    {
        FREE_ALL ;
        mexErrMsgTxt ("A failed") ;
    }
    mxClassID aclass = GB_mx_Type_to_classID (A->type) ;

    // get the number of entries in A
    GrB_Matrix_nvals (&nvals, A) ;

    mxClassID xclass ;
    GrB_Type xtype ;

    if (A->type == Complex)
    {
        // input argument xclass is ignored
        xtype = Complex ;
        xclass = mxDOUBLE_CLASS ;
        // create Xtemp
        if (nargout > 2)
        {
            GB_MALLOC_MEMORY (Xtemp, nvals, sizeof (double complex)) ;
        }
    }
    else
    {
        // get xclass, default is class (A), and the corresponding xtype
        xclass = GB_mx_string_to_classID (aclass, PARGIN (1)) ;
        xtype = GB_mx_classID_to_Type (xclass) ;
        if (xtype == NULL)
        {
            FREE_ALL ;
            mexErrMsgTxt ("X must be numeric") ;
        }
        // create X
        if (nargout > 2)
        {
            pargout [2] = mxCreateNumericMatrix (nvals, 1, xclass, mxREAL) ;
            X = (void *) mxGetData (pargout [2]) ;
        }
    }

    // create I
    pargout [0] = mxCreateNumericMatrix (nvals, 1, mxUINT64_CLASS, mxREAL) ;
    GrB_Index *I = (GrB_Index *) mxGetData (pargout [0]) ;

    // create J
    GrB_Index *J = NULL ;
    if (nargout > 1)
    {
        pargout [1] = mxCreateNumericMatrix (nvals, 1, mxUINT64_CLASS, mxREAL) ;
        J = (GrB_Index *) mxGetData (pargout [1]) ;
    }

    // [I,J,X] = find (A)
    if (GB_VECTOR_OK (A))
    {
        // test extract vector methods
        GrB_Vector v = (GrB_Vector) A ;
        switch (xtype->code)
        {
            case GB_BOOL_code   : METHOD (GrB_Vector_extractTuples (I, (bool     *) X, &nvals, v)) ; break ;
            case GB_INT8_code   : METHOD (GrB_Vector_extractTuples (I, (int8_t   *) X, &nvals, v)) ; break ;
            case GB_UINT8_code  : METHOD (GrB_Vector_extractTuples (I, (uint8_t  *) X, &nvals, v)) ; break ;
            case GB_INT16_code  : METHOD (GrB_Vector_extractTuples (I, (int16_t  *) X, &nvals, v)) ; break ;
            case GB_UINT16_code : METHOD (GrB_Vector_extractTuples (I, (uint16_t *) X, &nvals, v)) ; break ;
            case GB_INT32_code  : METHOD (GrB_Vector_extractTuples (I, (int32_t  *) X, &nvals, v)) ; break ;
            case GB_UINT32_code : METHOD (GrB_Vector_extractTuples (I, (uint32_t *) X, &nvals, v)) ; break ;
            case GB_INT64_code  : METHOD (GrB_Vector_extractTuples (I, (int64_t  *) X, &nvals, v)) ; break ;
            case GB_UINT64_code : METHOD (GrB_Vector_extractTuples (I, (uint64_t *) X, &nvals, v)) ; break ;
            case GB_FP32_code   : METHOD (GrB_Vector_extractTuples (I, (float    *) X, &nvals, v)) ; break ;
            case GB_FP64_code   : METHOD (GrB_Vector_extractTuples (I, (double   *) X, &nvals, v)) ; break ;
            case GB_UCT_code    : 
            case GB_UDT_code    : 
              METHOD (GrB_Vector_extractTuples (I, Xtemp, &nvals, v)) ; break ;
            default             : FREE_ALL ; mexErrMsgTxt ("unsupported class") ;
        }
        if (J != NULL)
        {
            for (int64_t p = 0 ; p < nvals ; p++) J [p] = 0 ;
        }
    }
    else
    {
        switch (xtype->code)
        {
            case GB_BOOL_code   : METHOD (GrB_Matrix_extractTuples (I, J, (bool     *) X, &nvals, A)) ; break ;
            case GB_INT8_code   : METHOD (GrB_Matrix_extractTuples (I, J, (int8_t   *) X, &nvals, A)) ; break ;
            case GB_UINT8_code  : METHOD (GrB_Matrix_extractTuples (I, J, (uint8_t  *) X, &nvals, A)) ; break ;
            case GB_INT16_code  : METHOD (GrB_Matrix_extractTuples (I, J, (int16_t  *) X, &nvals, A)) ; break ;
            case GB_UINT16_code : METHOD (GrB_Matrix_extractTuples (I, J, (uint16_t *) X, &nvals, A)) ; break ;
            case GB_INT32_code  : METHOD (GrB_Matrix_extractTuples (I, J, (int32_t  *) X, &nvals, A)) ; break ;
            case GB_UINT32_code : METHOD (GrB_Matrix_extractTuples (I, J, (uint32_t *) X, &nvals, A)) ; break ;
            case GB_INT64_code  : METHOD (GrB_Matrix_extractTuples (I, J, (int64_t  *) X, &nvals, A)) ; break ;
            case GB_UINT64_code : METHOD (GrB_Matrix_extractTuples (I, J, (uint64_t *) X, &nvals, A)) ; break ;
            case GB_FP32_code   : METHOD (GrB_Matrix_extractTuples (I, J, (float    *) X, &nvals, A)) ; break ;
            case GB_FP64_code   : METHOD (GrB_Matrix_extractTuples (I, J, (double   *) X, &nvals, A)) ; break;
            case GB_UCT_code    :
            case GB_UDT_code    :
                METHOD (GrB_Matrix_extractTuples (I, J, Xtemp, &nvals, A)) ; break;
            default             : FREE_ALL ; mexErrMsgTxt ("unsupported class") ;
        }
    }

    if (A->type == Complex && nargout > 2)
    {
        // create the MATLAB complex X
        pargout [2] = mxCreateNumericMatrix
            (nvals, 1, mxDOUBLE_CLASS, mxCOMPLEX) ;
        GB_mx_complex_split (nvals, Xtemp, pargout [2]) ;
    }

    FREE_ALL ;
}
コード例 #19
0
ファイル: modules.c プロジェクト: Rohansi/wren
#define CLASS(name) { #name, {
#define END_CLASS SENTINEL_METHOD } },

#define METHOD(signature, fn) { false, signature, fn },
#define STATIC_METHOD(signature, fn) { true, signature, fn },

// The array of built-in modules.
static ModuleRegistry modules[] =
{
  MODULE(io)
    CLASS(File)
      STATIC_METHOD("<allocate>", fileAllocate)
      STATIC_METHOD("<finalize>", fileFinalize)
      STATIC_METHOD("open_(_,_)", fileOpen)
      STATIC_METHOD("sizePath_(_,_)", fileSizePath)
      METHOD("close_(_)", fileClose)
      METHOD("descriptor", fileDescriptor)
      METHOD("readBytes_(_,_)", fileReadBytes)
      METHOD("size_(_)", fileSize)
    END_CLASS
    CLASS(Stdin)
      STATIC_METHOD("readStart_()", stdinReadStart)
      STATIC_METHOD("readStop_()", stdinReadStop)
    END_CLASS
  END_MODULE
  MODULE(scheduler)
    CLASS(Scheduler)
      STATIC_METHOD("captureMethods_()", schedulerCaptureMethods)
    END_CLASS
  END_MODULE
  MODULE(timer)
コード例 #20
0
ファイル: object.c プロジェクト: PKRoma/pygit2
    Py_INCREF(res);
    return res;
}

PyGetSetDef Object_getseters[] = {
    GETTER(Object, oid),
    GETTER(Object, id),
    GETTER(Object, hex),
    GETTER(Object, short_id),
    GETTER(Object, type),
    GETTER(Object, _pointer),
    {NULL}
};

PyMethodDef Object_methods[] = {
    METHOD(Object, read_raw, METH_NOARGS),
    METHOD(Object, peel, METH_O),
    {NULL}
};


PyDoc_STRVAR(Object__doc__, "Base class for Git objects.");

PyTypeObject ObjectType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "_pygit2.Object",                          /* tp_name           */
    sizeof(Object),                            /* tp_basicsize      */
    0,                                         /* tp_itemsize       */
    (destructor)Object_dealloc,                /* tp_dealloc        */
    0,                                         /* tp_print          */
    0,                                         /* tp_getattr        */
コード例 #21
0
ファイル: tree.c プロジェクト: jflesch/pygit2-mariadb
    0,                          /* sq_repeat */
    0,                          /* sq_item */
    0,                          /* sq_slice */
    0,                          /* sq_ass_item */
    0,                          /* sq_ass_slice */
    (objobjproc)Tree_contains,  /* sq_contains */
};

PyMappingMethods Tree_as_mapping = {
    (lenfunc)Tree_len,            /* mp_length */
    (binaryfunc)Tree_getitem,     /* mp_subscript */
    0,                            /* mp_ass_subscript */
};

PyMethodDef Tree_methods[] = {
    METHOD(Tree, diff_to_tree, METH_VARARGS | METH_KEYWORDS),
    METHOD(Tree, diff_to_workdir, METH_VARARGS),
    METHOD(Tree, diff_to_index, METH_VARARGS | METH_KEYWORDS),
    {NULL}
};


PyDoc_STRVAR(Tree__doc__, "Tree objects.");

PyTypeObject TreeType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "_pygit2.Tree",                            /* tp_name           */
    sizeof(Tree),                              /* tp_basicsize      */
    0,                                         /* tp_itemsize       */
    0,                                         /* tp_dealloc        */
    0,                                         /* tp_print          */
コード例 #22
0
ファイル: spxsolver.cpp プロジェクト: aimanqais/gerardus
void SPxSolver::setSolver(SLinSolver* slu, const bool destroy)
{
   METHOD( "SPxSolver::setSolver()" );
   SPxBasis::loadSolver(slu, destroy);
}
コード例 #23
0
ファイル: mext_methods.c プロジェクト: artfwo/serialosc
void
osc_register_methods(sosc_state_t *state)
{
	char *prefix, *cmd_buf;
	monome_t *monome;
	lo_server srv;

	prefix = state->config.app.osc_prefix;
	monome = state->monome;
	srv = state->server;

#define REGISTER(typetags, cb) \
	lo_server_add_method(srv, cmd_buf, typetags, cb, monome)

	METHOD("grid/led/set")
		REGISTER("iii", led_set_handler);

	METHOD("grid/led/all")
		REGISTER("i", led_all_handler);

	METHOD("grid/led/map")
		REGISTER("iiiiiiiiii", led_map_handler);

	METHOD("grid/led/col")
		REGISTER(NULL, led_col_handler);

	METHOD("grid/led/row")
		REGISTER(NULL, led_row_handler);

	METHOD("grid/led/intensity")
		REGISTER("i", led_intensity_handler);

	METHOD("grid/led/level/set")
		REGISTER("iii", led_level_set_handler);

	METHOD("grid/led/level/all")
		REGISTER("i", led_level_all_handler);

	METHOD("grid/led/level/map")
		REGISTER("ii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii",
		         led_level_map_handler);

	METHOD("grid/led/level/col")
		REGISTER(NULL, led_level_col_handler);

	METHOD("grid/led/level/row")
		REGISTER(NULL, led_level_row_handler);

	METHOD("ring/set")
		REGISTER("iii", led_ring_set_handler);

	METHOD("ring/all")
		REGISTER("ii", led_ring_all_handler);

	METHOD("ring/map")
		REGISTER("i"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii"
		         "iiiiiiii",
		         led_ring_map_handler);

	METHOD("ring/range")
		REGISTER("iiii", led_ring_range_handler);

	METHOD("tilt/set")
		REGISTER("ii", tilt_set_handler);

#undef REGISTER
}
コード例 #24
0
OP_ERROR
SOP_PrimCentroid::cookMySop(OP_Context &context)
{
    fpreal                      now;
    int                         method;

    const GA_Attribute          *source_attr;
    const GA_AttributeDict      *dict;
    GA_AttributeDict::iterator  a_it;
    GA_Offset                   ptOff;
    GA_RWAttributeRef           n_gah;
    GA_RWHandleV3               n_h;

    const GEO_Primitive         *prim;

    const GU_Detail             *input_geo;

    UT_BoundingBox              bbox;
    UT_String                   pattern, attr_name;
    UT_WorkArgs                 tokens;

    now = context.getTime();

    if (lockInputs(context) >= UT_ERROR_ABORT)
        return error();

    // Clear out any previous data.
    gdp->clearAndDestroy();

    // Get the input geometry as read only.
    GU_DetailHandleAutoReadLock gdl(inputGeoHandle(0));
    input_geo = gdl.getGdp();

    // Find out which calculation method we are attempting.
    method = METHOD(now);

    // Create the standard point normal (N) attribute.
    n_gah = gdp->addNormalAttribute(GA_ATTRIB_POINT);

    // Bind a read/write attribute handle to the normal attribute.
    n_h.bind(n_gah.getAttribute());

    // Construct an attribute reference map to map attributes.
    GA_AttributeRefMap hmap(*gdp, input_geo);

    // Get the attribute selection string.
    ATTRIBUTES(pattern, now);

    // Make sure we entered something.
    if (pattern.length() > 0)
    {
        // Tokenize the pattern.
        pattern.tokenize(tokens, " ");

        // The primitive attributes on the incoming geometry.
        dict = &input_geo->primitiveAttribs();

        // Iterate over all the primitive attributes.
        for (a_it=dict->begin(GA_SCOPE_PUBLIC); !a_it.atEnd(); ++a_it)
        {
            // The current attribute.
            source_attr = a_it.attrib();

            // Get the attribute name.
            attr_name = source_attr->getName();

            // If the name doesn't match our pattern, skip it.
            if (!attr_name.matchPattern(tokens))
                continue;

            // Create a new point attribute on the current geometry
            // that is the same as the source attribute.  Append it and
            // the source to the map.
            hmap.append(gdp->addPointAttrib(source_attr).getAttribute(),
                        source_attr);
        }

        // Copy local variables.
        if (COPY(now))
        {
            // Traverse the variable names on the input geometry and attempt to
            // copy any that match to our new geometry.
            input_geo->traverseVariableNames(
                SOP_PrimCentroid::copyLocalVariables,
                gdp
            );
        }
    }

    // Get the list of input primitives.
    const GA_PrimitiveList &prim_list = input_geo->getPrimitiveList();

    // Add points for each primitive.
    ptOff = gdp->appendPointBlock(input_geo->getNumPrimitives());

    // Iterate over primitives using pages.
    for (GA_Iterator it(input_geo->getPrimitiveRange()); !it.atEnd(); ++it)
    {
        // Get the primitive from the list.
        prim = (const GEO_Primitive *) prim_list.get(*it);

        if (method)
        {
            // Get the bounding box for the primitive and set the point's
            // position to be the center of the box.
            prim->getBBox(&bbox);
            gdp->setPos3(ptOff, bbox.center());
        }
        else
            // Set the point's position to be the bary center of the primitive
            gdp->setPos3(ptOff, prim->baryCenter());

        // Set the point's normal to be the normal of the primitive.
        n_h.set(ptOff, prim->computeNormal());

        // If we are copying attributes, copy the primitive attributes from
        // the current primitive to the new point.
        if (hmap.entries() > 0)
            hmap.copyValue(GA_ATTRIB_POINT, ptOff, GA_ATTRIB_PRIMITIVE, *it);

        // Increment the point offset.
        ptOff++;
    }

    unlockInputs();
    return error();
}
コード例 #25
0
ファイル: remote.c プロジェクト: shinningstar/pygit2
    if (err < 0) {
        free(trans);
        Error_set(err);
        return NULL;
    }

    py_trans = to_unicode(trans, NULL, NULL);

    free(trans);

    return py_trans;
}

PyMethodDef Refspec_methods[] = {
    METHOD(Refspec, src_matches, METH_O),
    METHOD(Refspec, dst_matches, METH_O),
    METHOD(Refspec, transform, METH_O),
    METHOD(Refspec, rtransform, METH_O),
    {NULL}
};

PyGetSetDef Refspec_getseters[] = {
    GETTER(Refspec, direction),
    GETTER(Refspec, src),
    GETTER(Refspec, dst),
    GETTER(Refspec, string),
    GETTER(Refspec, force),
    {NULL}
};
コード例 #26
0
ファイル: repository.c プロジェクト: cboos/pygit2
    git_remote_list(&remotes, self->repo);

    py_list = PyList_New(remotes.count);
    for (i=0; i < remotes.count; ++i) {
        py_tmp = INSTANCIATE_CLASS(RemoteType, Py_BuildValue("Os", self, remotes.strings[i]));
        PyList_SetItem(py_list, i, py_tmp);
    }

    git_strarray_free(&remotes);

    return py_list;
}


PyMethodDef Repository_methods[] = {
    METHOD(Repository, create_blob, METH_VARARGS),
    METHOD(Repository, create_blob_fromfile, METH_VARARGS),
    METHOD(Repository, create_commit, METH_VARARGS),
    METHOD(Repository, create_tag, METH_VARARGS),
    METHOD(Repository, TreeBuilder, METH_VARARGS),
    METHOD(Repository, walk, METH_VARARGS),
    METHOD(Repository, read, METH_O),
    METHOD(Repository, write, METH_VARARGS),
    METHOD(Repository, create_reference, METH_VARARGS|METH_KEYWORDS),
    METHOD(Repository, listall_references, METH_VARARGS),
    METHOD(Repository, lookup_reference, METH_O),
    METHOD(Repository, packall_references, METH_NOARGS),
    METHOD(Repository, revparse_single, METH_O),
    METHOD(Repository, status, METH_NOARGS),
    METHOD(Repository, status_file, METH_O),
    METHOD(Repository, remote_create, METH_VARARGS),
コード例 #27
0
ファイル: diff.c プロジェクト: goibibo/pygit2
    PyObject_Del(self);
}

PyGetSetDef Diff_getseters[] = {
    GETTER(Diff, patch),
    {NULL}
};

PyMappingMethods Diff_as_mapping = {
    (lenfunc)Diff_len,               /* mp_length */
    (binaryfunc)Diff_getitem,        /* mp_subscript */
    0,                               /* mp_ass_subscript */
};

static PyMethodDef Diff_methods[] = {
    METHOD(Diff, merge, METH_VARARGS),
    METHOD(Diff, find_similar, METH_VARARGS),
    {NULL}
};


PyDoc_STRVAR(Diff__doc__, "Diff objects.");

PyTypeObject DiffType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "_pygit2.Diff",                            /* tp_name           */
    sizeof(Diff),                              /* tp_basicsize      */
    0,                                         /* tp_itemsize       */
    (destructor)Diff_dealloc,                  /* tp_dealloc        */
    0,                                         /* tp_print          */
    0,                                         /* tp_getattr        */
コード例 #28
0
ファイル: tree.c プロジェクト: heynemann/pygit2
    0,                          /* sq_repeat */
    0,                          /* sq_item */
    0,                          /* sq_slice */
    0,                          /* sq_ass_item */
    0,                          /* sq_ass_slice */
    (objobjproc)Tree_contains,  /* sq_contains */
};

PyMappingMethods Tree_as_mapping = {
    (lenfunc)Tree_len,            /* mp_length */
    (binaryfunc)Tree_getitem,     /* mp_subscript */
    0,                            /* mp_ass_subscript */
};

PyMethodDef Tree_methods[] = {
    METHOD(Tree, diff, METH_VARARGS | METH_KEYWORDS),
    {NULL}
};


PyDoc_STRVAR(Tree__doc__, "Tree objects.");

PyTypeObject TreeType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "_pygit2.Tree",                            /* tp_name           */
    sizeof(Tree),                              /* tp_basicsize      */
    0,                                         /* tp_itemsize       */
    0,                                         /* tp_dealloc        */
    0,                                         /* tp_print          */
    0,                                         /* tp_getattr        */
    0,                                         /* tp_setattr        */
コード例 #29
0
ファイル: haltest.c プロジェクト: DgFutureLab/blePi
static void source_p(int argc, const char **argv)
{
	if (argc < 2) {
		haltest_error("No file specified");
		return;
	}

	process_file(argv[1]);
}

/* Commands available without interface */
static struct method commands[] = {
	STD_METHODCH(help, "[<interface>]"),
	STD_METHOD(quit),
	METHOD("exit", quit_p, NULL, NULL),
	STD_METHODH(source, "<file>"),
	END_METHOD
};

/* Gets comman by name */
struct method *get_command(const char *name)
{
	return get_method(commands, name);
}

/* Function to enumerate interface names */
const char *interface_name(void *v, int i)
{
	return interfaces[i] ? interfaces[i]->name : NULL;
}
コード例 #30
0
ファイル: object.c プロジェクト: masdude/pygit2
        git_odb_object_data(obj),
        git_odb_object_size(obj));

    git_odb_object_free(obj);
    return aux;
}

PyGetSetDef Object_getseters[] = {
    GETTER(Object, oid),
    GETTER(Object, hex),
    GETTER(Object, type),
    {NULL}
};

PyMethodDef Object_methods[] = {
    METHOD(Object, read_raw, METH_NOARGS),
    {NULL}
};


PyDoc_STRVAR(Object__doc__, "Base class for Git objects.");

PyTypeObject ObjectType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "_pygit2.Object",                          /* tp_name           */
    sizeof(Object),                            /* tp_basicsize      */
    0,                                         /* tp_itemsize       */
    (destructor)Object_dealloc,                /* tp_dealloc        */
    0,                                         /* tp_print          */
    0,                                         /* tp_getattr        */
    0,                                         /* tp_setattr        */