FCIMPL1(void, ArrayNative::Initialize, ArrayBase* array)
{
FCALL_CONTRACT;
if (array == NULL)
{
FCThrowVoid(kNullReferenceException);
}
MethodTable* pArrayMT = array->GetMethodTable();
TypeHandle thElem = pArrayMT->GetApproxArrayElementTypeHandle();
if (thElem.IsTypeDesc())
return;
MethodTable * pElemMT = thElem.AsMethodTable();
if (!pElemMT->HasDefaultConstructor() || !pElemMT->IsValueType())
return;
ARRAYBASEREF arrayRef (array);
HELPER_METHOD_FRAME_BEGIN_1(arrayRef);
ArrayInitializeWorker(&arrayRef, pArrayMT, pElemMT);
HELPER_METHOD_FRAME_END();
}
/* Get method specifications */
const MethodTable& RateMatrix::getMethods(void) const {
static MethodTable methods = MethodTable();
static bool methodsSet = false;
if ( methodsSet == false ) {
// add method for call "x[]" as a function
ArgumentRules* squareBracketArgRules = new ArgumentRules();
squareBracketArgRules->push_back( new ArgumentRule( "index" , true, Natural::getClassTypeSpec() ) );
methods.addFunction("[]", new MemberProcedure( ModelVector<RealPos>::getClassTypeSpec(), squareBracketArgRules) );
// add method for call "x[]" as a function
ArgumentRules* sizeArgRules = new ArgumentRules();
methods.addFunction("size", new MemberProcedure( Natural::getClassTypeSpec(), sizeArgRules) );
// necessary call for proper inheritance
methods.setParentTable( &ModelObject<RevBayesCore::RateMatrix>::getMethods() );
methodsSet = true;
}
return methods;
}
void CallFinalizer(Object* obj)
{
STATIC_CONTRACT_THROWS;
STATIC_CONTRACT_GC_TRIGGERS;
STATIC_CONTRACT_MODE_COOPERATIVE;
MethodTable *pMT = obj->GetMethodTable();
STRESS_LOG2(LF_GC, LL_INFO1000, "Finalizing object %p MT %pT\n", obj, pMT);
LOG((LF_GC, LL_INFO1000, "Finalizing " LOG_OBJECT_CLASS(obj)));
_ASSERTE(GetThread()->PreemptiveGCDisabled());
// if we don't have a class, we can't call the finalizer
// if the object has been marked run as finalizer run don't call either
if (pMT)
{
if (!((obj->GetHeader()->GetBits()) & BIT_SBLK_FINALIZER_RUN))
{
_ASSERTE(obj->GetMethodTable() == pMT);
_ASSERTE(pMT->HasFinalizer() || pMT->IsTransparentProxy());
LogFinalization(obj);
MethodTable::CallFinalizer(obj);
}
else
{
//reset the bit so the object can be put on the list
//with RegisterForFinalization
obj->GetHeader()->ClrBit (BIT_SBLK_FINALIZER_RUN);
}
}
}
/* Get method specifications */
const MethodTable& ParallelMcmcmc::getMethods(void) const {
static MethodTable methods = MethodTable();
static bool methodsSet = false;
if ( methodsSet == false ) {
ArgumentRules* runArgRules = new ArgumentRules();
runArgRules->push_back( new ArgumentRule("generations", true, Natural::getClassTypeSpec()) );
methods.addFunction("run", new MemberProcedure( RlUtils::Void, runArgRules) );
ArgumentRules* burninArgRules = new ArgumentRules();
burninArgRules->push_back( new ArgumentRule("generations", true, Natural::getClassTypeSpec()) );
burninArgRules->push_back( new ArgumentRule("tuningInterval", true, Natural::getClassTypeSpec()) );
methods.addFunction("burnin", new MemberProcedure( RlUtils::Void, burninArgRules) );
ArgumentRules* operatorSummaryArgRules = new ArgumentRules();
methods.addFunction("operatorSummary", new MemberProcedure( RlUtils::Void, operatorSummaryArgRules) );
// necessary call for proper inheritance
methods.setParentTable( &RevObject::getMethods() );
methodsSet = true;
}
return methods;
}
void MethodTable::Info::show(STATE, Object* self, int level) {
MethodTable* tbl = as<MethodTable>(self);
size_t size = tbl->bins()->to_native();
if(size == 0) {
class_info(state, self, true);
return;
}
class_info(state, self);
std::cout << ": " << size << std::endl;
indent(++level);
for(size_t i = 0; i < size; i++) {
MethodTableBucket* entry = try_as<MethodTableBucket>(tbl->values()->at(state, i));
while(entry) {
if(Symbol* sym = try_as<Symbol>(entry->name())) {
std::cout << ":" << sym->debug_str(state);
} else if(Fixnum* fix = try_as<Fixnum>(entry->name())) {
std::cout << fix->to_native();
}
entry = try_as<MethodTableBucket>(entry->next());
}
if(i < size - 1) std::cout << ", ";
}
std::cout << std::endl;
close_body(level);
}
MethodTable* MethodTable::duplicate(STATE) {
size_t size, i;
MethodTable* dup = 0;
utilities::thread::SpinLock::LockGuard lg(lock_);
size = bins_->to_native();
dup = MethodTable::create(state, size);
// Allow for subclassing.
dup->klass(state, class_object(state));
size_t num = bins_->to_native();
MethodTableBucket* entry = 0;
for(i = 0; i < num; i++) {
entry = try_as<MethodTableBucket>(values_->at(state, i));
while(entry) {
dup->store(state, entry->name(), entry->method(), entry->visibility());
entry = try_as<MethodTableBucket>(entry->next());
}
}
return dup;
}
MethodTable* MethodTable::create(STATE, size_t size) {
MethodTable *tbl;
tbl = state->memory()->new_object<MethodTable>(state, G(method_table));
tbl->setup(state, size);
return tbl;
}
MethodTable* MethodTable::create(STATE, size_t size) {
MethodTable *tbl;
tbl = state->new_object<MethodTable>(G(methtbl));
tbl->setup(state, size);
return tbl;
}
static void hookup_prim(STATE, Symbol* meth, Symbol* prim) {
MethodTable* tbl = G(rubinius)->metaclass(state)->method_table();
Executable* oc = Executable::allocate(state, Qnil);
oc->primitive(state, prim);
assert(oc->resolve_primitive(state));
tbl->store(state, meth, oc, G(sym_public));
}
MethodTable Dist_CharacterDependentCladoBirthDeathProcess::getDistributionMethods( void ) const
{
MethodTable methods = TypedDistribution<TimeTree>::getDistributionMethods();
ArgumentRules* clampCharDataArgRules = new ArgumentRules();
clampCharDataArgRules->push_back( new ArgumentRule( "value", AbstractHomologousDiscreteCharacterData::getClassTypeSpec(), "The observed value.", ArgumentRule::BY_VALUE, ArgumentRule::ANY ) );
methods.addFunction( new MemberProcedure( "clampCharData", RlUtils::Void, clampCharDataArgRules ) );
return methods;
}
MethodDesc *Binder::RawGetMethod(BinderMethodID id)
{
CANNOTTHROWCOMPLUSEXCEPTION();
_ASSERTE(m_pModule != NULL);
_ASSERTE(id != METHOD__NIL);
_ASSERTE(id <= m_cMethodRIDs);
const MethodDescription *d = m_methodDescriptions + id - 1;
MethodTable *pMT = RawGetClass(d->classID);
_ASSERTE(pMT != NULL);
MethodDesc *pMD = pMT->GetMethodDescForSlot(m_pMethodRIDs[id-1]-1);
_ASSERTE(pMD != NULL);
return pMD;
}
MethodTable *Binder::LookupClass(BinderClassID id, BOOL fLoad)
{
_ASSERTE(m_pModule != NULL);
_ASSERTE(id != CLASS__NIL);
_ASSERTE(id <= m_cClassRIDs);
MethodTable *pMT;
const ClassDescription *d = m_classDescriptions + id - 1;
NameHandle nh(d->name);
if (!fLoad)
{
nh.SetTokenNotToLoad(tdAllTypes);
pMT = m_pModule->GetClassLoader()->FindTypeHandle(&nh).AsMethodTable();
if (pMT == NULL)
return NULL;
}
else
{
THROWSCOMPLUSEXCEPTION();
BEGIN_ENSURE_COOPERATIVE_GC();
OBJECTREF pThrowable = NULL;
GCPROTECT_BEGIN(pThrowable);
pMT = m_pModule->GetClassLoader()->FindTypeHandle(&nh, &pThrowable).AsMethodTable();
if (pMT == NULL)
{
_ASSERTE(!"EE expects class to exist");
COMPlusThrow(pThrowable);
}
GCPROTECT_END();
END_ENSURE_COOPERATIVE_GC();
}
_ASSERTE(pMT->GetModule() == m_pModule);
mdTypeDef td = pMT->GetClass()->GetCl();
_ASSERTE(!IsNilToken(td));
_ASSERTE(RidFromToken(td) <= USHRT_MAX);
m_pClassRIDs[id-1] = (USHORT) RidFromToken(td);
m_pModule->StoreTypeDef(td, pMT);
return pMT;
}
MethodTable Dist_sampledSpeciationBirthDeathProcess::getDistributionMethods( void ) const
{
MethodTable methods = TypedDistribution<TimeTree>::getDistributionMethods();
// member functions
ArgumentRules* numEventsArgRules = new ArgumentRules();
// parentArgRules->push_back( new ArgumentRule( "node", Natural::getClassTypeSpec(), "The index of the node.", ArgumentRule::BY_CONSTANT_REFERENCE, ArgumentRule::ANY ) );
methods.addFunction( new DistributionMemberFunction<Dist_sampledSpeciationBirthDeathProcess, ModelVector<Natural> >( "numberEvents", variable, numEventsArgRules ) );
methods.addFunction( new DistributionMemberFunction<Dist_sampledSpeciationBirthDeathProcess, ModelVector<ModelVector<RealPos> > >( "eventTimes", variable, numEventsArgRules ) );
return methods;
}
int GetVersionResilientTypeHashCode(TypeHandle type)
{
if (!type.IsTypeDesc())
{
MethodTable *pMT = type.AsMethodTable();
_ASSERTE(!pMT->IsArray());
_ASSERTE(!IsNilToken(pMT->GetCl()));
LPCUTF8 szNamespace;
LPCUTF8 szName;
IfFailThrow(pMT->GetMDImport()->GetNameOfTypeDef(pMT->GetCl(), &szName, &szNamespace));
int hashcode = ComputeNameHashCode(szNamespace, szName);
MethodTable *pMTEnclosing = pMT->LoadEnclosingMethodTable(CLASS_LOAD_UNRESTOREDTYPEKEY);
if (pMTEnclosing != NULL)
{
hashcode = ComputeNestedTypeHashCode(GetVersionResilientTypeHashCode(TypeHandle(pMTEnclosing)), hashcode);
}
if (!pMT->IsGenericTypeDefinition() && pMT->HasInstantiation())
{
return ComputeGenericInstanceHashCode(hashcode,
pMT->GetInstantiation().GetNumArgs(), pMT->GetInstantiation(), GetVersionResilientTypeHashCode);
}
else
{
return hashcode;
}
}
else
if (type.IsArray())
{
ArrayTypeDesc *pArray = type.AsArray();
return ComputeArrayTypeHashCode(GetVersionResilientTypeHashCode(pArray->GetArrayElementTypeHandle()), pArray->GetRank());
}
else
if (type.IsPointer())
{
return ComputePointerTypeHashCode(GetVersionResilientTypeHashCode(type.AsTypeDesc()->GetTypeParam()));
}
else
if (type.IsByRef())
{
return ComputeByrefTypeHashCode(GetVersionResilientTypeHashCode(type.AsTypeDesc()->GetTypeParam()));
}
assert(false);
return 0;
}
MethodTable AbstractCharacterData::getCharacterDataMethods( void ) const
{
MethodTable methods = MethodTable();
ArgumentRules* namesArgRules = new ArgumentRules();
ArgumentRules* ntaxaArgRules = new ArgumentRules();
ArgumentRules* excludeTaxaArgRules = new ArgumentRules();
ArgumentRules* excludeTaxaArgRules2 = new ArgumentRules();
ArgumentRules* includeTaxaArgRules = new ArgumentRules();
ArgumentRules* includeTaxaArgRules2 = new ArgumentRules();
ArgumentRules* isSequenceMissingArgRules = new ArgumentRules();
ArgumentRules* percentageMissingArgRules = new ArgumentRules();
ArgumentRules* showdataArgRules = new ArgumentRules();
ArgumentRules* removeTaxaArgRules = new ArgumentRules();
ArgumentRules* removeTaxaArgRules2 = new ArgumentRules();
ArgumentRules* setTaxonNameArgRules = new ArgumentRules();
excludeTaxaArgRules->push_back( new ArgumentRule("" , RlString::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
excludeTaxaArgRules2->push_back( new ArgumentRule("" , ModelVector<RlString>::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
includeTaxaArgRules->push_back( new ArgumentRule("" , RlString::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
includeTaxaArgRules2->push_back( new ArgumentRule("" , ModelVector<RlString>::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
isSequenceMissingArgRules->push_back( new ArgumentRule("" , RlString::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
percentageMissingArgRules->push_back( new ArgumentRule("" , RlString::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
removeTaxaArgRules->push_back( new ArgumentRule("" , RlString::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
removeTaxaArgRules2->push_back( new ArgumentRule("" , ModelVector<RlString>::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
setTaxonNameArgRules->push_back( new ArgumentRule("current" , RlString::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
setTaxonNameArgRules->push_back( new ArgumentRule("new" , RlString::getClassTypeSpec() , ArgumentRule::BY_VALUE) );
methods.addFunction("excludeTaxa", new MemberProcedure(RlUtils::Void, excludeTaxaArgRules ) );
methods.addFunction("excludeTaxa", new MemberProcedure(RlUtils::Void, excludeTaxaArgRules2 ) );
methods.addFunction("includeTaxa", new MemberProcedure(RlUtils::Void, includeTaxaArgRules ) );
methods.addFunction("includeTaxa", new MemberProcedure(RlUtils::Void, includeTaxaArgRules2 ) );
methods.addFunction("isSequenceMissing", new MemberProcedure(RlBoolean::getClassTypeSpec(), isSequenceMissingArgRules ) );
methods.addFunction("names", new MemberProcedure(ModelVector<RlString>::getClassTypeSpec(), namesArgRules ) );
methods.addFunction("ntaxa", new MemberProcedure(Natural::getClassTypeSpec(), ntaxaArgRules ) );
methods.addFunction("percentageMissing", new MemberProcedure(Probability::getClassTypeSpec(), percentageMissingArgRules ) );
methods.addFunction("show", new MemberProcedure(RlUtils::Void, showdataArgRules ) );
methods.addFunction("removeTaxa", new MemberProcedure(RlUtils::Void, removeTaxaArgRules ) );
methods.addFunction("removeTaxa", new MemberProcedure(RlUtils::Void, removeTaxaArgRules2 ) );
methods.addFunction("setTaxonName", new MemberProcedure(RlUtils::Void, setTaxonNameArgRules ) );
// Add method for call "size" as a function
ArgumentRules* sizeArgRules = new ArgumentRules();
methods.addFunction("size", new MemberProcedure( Natural::getClassTypeSpec(), sizeArgRules) );
return methods;
}
void System::attach_primitive(STATE, Module* mod, bool meta, Symbol* name, Symbol* prim) {
MethodTable* tbl;
if(meta) {
tbl = mod->singleton_class(state)->method_table();
} else {
tbl = mod->method_table();
}
Executable* oc = Executable::allocate(state, Qnil);
oc->primitive(state, prim);
oc->resolve_primitive(state);
tbl->store(state, name, oc, G(sym_public));
}
void SigTypeContext::InitTypeContext(MethodDesc *md, Instantiation exactClassInst, Instantiation exactMethodInst, SigTypeContext *pRes)
{
LIMITED_METHOD_CONTRACT;
STATIC_CONTRACT_SO_TOLERANT;
MethodTable *pMT = md->GetMethodTable();
if (pMT->IsArray())
{
pRes->m_classInst = exactClassInst.IsEmpty() ? pMT->GetClassOrArrayInstantiation() : exactClassInst;
}
else
{
pRes->m_classInst = exactClassInst;
}
pRes->m_methodInst = exactMethodInst;
}
/* Get method specifications */
const MethodTable& SteppingStoneSampler::getMethods(void) const {
static MethodTable methods = MethodTable();
static bool methodsSet = false;
if ( methodsSet == false )
{
ArgumentRules* marginalArgRules = new ArgumentRules();
methods.addFunction("marginal", new MemberProcedure( Real::getClassTypeSpec(), marginalArgRules) );
// necessary call for proper inheritance
methods.setParentTable( &RevObject::getMethods() );
methodsSet = true;
}
return methods;
}
/** Make member methods for this class */
RevLanguage::MethodTable TimeTree::makeMethods( void ) const
{
MethodTable methods = MethodTable();
ArgumentRules* nnodesArgRules = new ArgumentRules();
methods.addFunction("nnodes", new MemberProcedure(Natural::getClassTypeSpec(), nnodesArgRules ) );
ArgumentRules* ntipsArgRules = new ArgumentRules();
methods.addFunction("ntips", new MemberProcedure(Natural::getClassTypeSpec(), ntipsArgRules ) );
ArgumentRules* heightArgRules = new ArgumentRules();
methods.addFunction("rootAge", new MemberProcedure(RealPos::getClassTypeSpec(), heightArgRules ) );
ArgumentRules* namesArgRules = new ArgumentRules();
methods.addFunction("names", new MemberProcedure(ModelVector<RlString>::getClassTypeSpec(), namesArgRules ) );
ArgumentRules* rescaleArgRules = new ArgumentRules();
rescaleArgRules->push_back( new ArgumentRule( "factor", RealPos::getClassTypeSpec(), ArgumentRule::BY_VALUE ) );
methods.addFunction("rescale", new MemberProcedure(RlUtils::Void, rescaleArgRules ) );
// Insert inherited methods
methods.insertInheritedMethods( ModelObject<RevBayesCore::TimeTree>::makeMethods() );
return methods;
}
/* Get method specifications */
const RevLanguage::MethodTable& RealNodeValTree::getMethods(void) const {
static MethodTable methods = MethodTable();
static bool methodsSet = false;
if ( methodsSet == false )
{
ArgumentRules* meanArgRules = new ArgumentRules();
methods.addFunction("mean", new MemberFunction<RealNodeValTree,Real>( this, meanArgRules ) );
ArgumentRules* tipmeanArgRules = new ArgumentRules();
methods.addFunction("tipMean", new MemberFunction<RealNodeValTree,Real>( this, tipmeanArgRules ) );
ArgumentRules* stdevArgRules = new ArgumentRules();
methods.addFunction("stdev", new MemberFunction<RealNodeValTree,RealPos>( this, stdevArgRules ) );
ArgumentRules* rootArgRules = new ArgumentRules();
methods.addFunction("rootVal", new MemberProcedure(Real::getClassTypeSpec(), rootArgRules ) );
ArgumentRules* clampArgRules = new ArgumentRules();
clampArgRules->push_back(new ArgumentRule("data", false, AbstractCharacterData::getClassTypeSpec()));
clampArgRules->push_back(new ArgumentRule("dataIndex", false, Natural::getClassTypeSpec()));
methods.addFunction("clampAt", new MemberProcedure(RealNodeValTree::getClassTypeSpec(), clampArgRules ) );
// necessary call for proper inheritance
methods.setParentTable( &ModelObject<RevBayesCore::RealNodeContainer>::getMethods() );
methodsSet = true;
}
return methods;
}
FieldDesc *Binder::LookupField(BinderFieldID id)
{
_ASSERTE(m_pModule != NULL);
_ASSERTE(id != FIELD__NIL);
_ASSERTE(id <= m_cFieldRIDs);
THROWSCOMPLUSEXCEPTION();
const FieldDescription *d = m_fieldDescriptions + id - 1;
MethodTable *pMT = FetchClass(d->classID);
FieldDesc *pFD;
pFD = pMT->GetClass()->FindField(d->name, d->sig);
_ASSERTE(pFD != NULL || !"EE expects field to exist");
_ASSERTE(pFD - pMT->GetClass()->GetFieldDescListRaw() >= 0);
_ASSERTE(pFD - pMT->GetClass()->GetFieldDescListRaw() < (pMT->GetClass()->GetNumStaticFields()
+ pMT->GetClass()->GetNumIntroducedInstanceFields()));
_ASSERTE(pFD - pMT->GetClass()->GetFieldDescListRaw() + 1 < USHRT_MAX);
USHORT index = (USHORT)(pFD - pMT->GetClass()->GetFieldDescListRaw());
m_pFieldRIDs[id-1] = index+1;
// Go ahead and fill in the rid map since we're here anyway
m_pModule->StoreFieldDef(pFD->GetMemberDef(), pFD);
return pFD;
}
/** Insert inherited methods into method table */
void MethodTable::insertInheritedMethods( const MethodTable& inheritedMethods )
{
for ( MethodTable::const_iterator it = inheritedMethods.begin(); it != inheritedMethods.end(); ++it )
{
Function* theFunction = (*it).second->clone();
try
{
addFunction( (*it).first, theFunction );
}
catch ( RbException )
{
// Exception if we cannot overload. We do not worry about that
// but need to delete the superfluous function
delete theFunction;
}
}
}
FieldDesc *Binder::RawGetField(BinderFieldID id)
{
CANNOTTHROWCOMPLUSEXCEPTION();
_ASSERTE(m_pModule != NULL);
_ASSERTE(id != FIELD__NIL);
_ASSERTE(id <= m_cFieldRIDs);
const FieldDescription *f = m_fieldDescriptions + id - 1;
MethodTable *pMT = RawGetClass(f->classID);
_ASSERTE(pMT != NULL);
// Can't do this because the class may not be restored yet.
// _ASSERTE(m_pFieldRIDs[id-1]-1 < (pMT->GetClass()->GetNumStaticFields()
// + pMT->GetClass()->GetNumIntroducedInstanceFields()));
FieldDesc *pFD = pMT->GetClass()->GetFieldDescListRaw() + m_pFieldRIDs[id-1]-1;
_ASSERTE(pFD != NULL);
return pFD;
}
MethodTable* MethodTable::duplicate(STATE) {
size_t size, i;
MethodTable *dup;
size = bins_->to_native();
dup = MethodTable::create(state, size);
// Allow for subclassing.
dup->klass(state, class_object(state));
size_t num = entries_->to_native();
Array* entries = all_entries(state);
for(i = 0; i < num; i++) {
MethodTableBucket* entry = as<MethodTableBucket>(entries->get(state, i));
dup->store(state, entry->name(), entry->method(), entry->visibility());
}
return dup;
}
/** Insert inherited methods into method table */
void MethodTable::insertInheritedMethods( const MethodTable& inheritedMethods )
{
for ( MethodTable::const_iterator it = inheritedMethods.begin(); it != inheritedMethods.end(); ++it )
{
Function* theFunction = (*it).second->clone();
try
{
addFunction( theFunction );
}
catch ( RbException )
{
}
}
}
MethodTable *Binder::FetchClass(BinderClassID id)
{
THROWSCOMPLUSEXCEPTION();
_ASSERTE(id != CLASS__NIL);
_ASSERTE(id <= m_cClassRIDs);
MethodTable *pMT;
if (m_pClassRIDs[id-1] == 0)
pMT = LookupClass(id);
else
{
pMT = RawGetClass(id);
pMT->CheckRestore();
}
return pMT;
}
/* Get method specifications */
const RevLanguage::MethodTable& Taxon::getMethods(void) const {
static MethodTable methods = MethodTable();
static bool methodsSet = false;
if ( methodsSet == false ) {
// ArgumentRules* nnodesArgRules = new ArgumentRules();
// methods.addFunction("nnodes", new MemberProcedure(Natural::getClassTypeSpec(), nnodesArgRules ) );
//
// ArgumentRules* namesArgRules = new ArgumentRules();
// methods.addFunction("names", new MemberProcedure(ModelVector<RlString>::getClassTypeSpec(), namesArgRules ) );
// necessary call for proper inheritance
methods.setParentTable( &RevObject::getMethods() );
methodsSet = true;
}
return methods;
}
MethodTable RlAtlas::makeMethods( void ) const
{
MethodTable methods;
ArgumentRules* nAreasArgRules = new ArgumentRules();
ArgumentRules* nEpochsArgRules = new ArgumentRules();
ArgumentRules* namesArgRules = new ArgumentRules();
methods.addFunction("names", new MemberProcedure(ModelVector<RlString>::getClassTypeSpec(), namesArgRules ) );
methods.addFunction("nAreas", new MemberProcedure(Natural::getClassTypeSpec(), nAreasArgRules ) );
methods.addFunction("nEpochs", new MemberProcedure(Natural::getClassTypeSpec(), nEpochsArgRules ) );
// Add method for call "size" as a function
ArgumentRules* sizeArgRules = new ArgumentRules();
methods.addFunction("size", new MemberProcedure( Natural::getClassTypeSpec(), sizeArgRules) );
// Insert inherited methods
methods.insertInheritedMethods( ModelObject<RevBayesCore::TimeAtlas>::makeMethods() );
return methods;
}
extern "C" Object * __castclass_class(void * p, MethodTable * pTargetMT)
{
Object * o = (Object *)p;
if (o == NULL)
return o;
MethodTable * pMT = o->RawGetMethodTable();
do {
if (pMT == pTargetMT)
return o;
if (pMT->IsArray())
break;
pMT = pMT->GetParent();
} while (pMT);
// TODO: Handle corner cases, throw proper exception
throw "__castclass_class";
}
extern "C" Object * __isinst_class(void * p, MethodTable * pTargetMT)
{
Object * o = (Object *)p;
if (o == NULL)
return o;
MethodTable * pMT = o->RawGetMethodTable();
do {
if (pMT == pTargetMT)
return o;
if (pMT->IsArray())
break;
pMT = pMT->GetParent();
} while (pMT);
// TODO: Handle corner cases
return NULL;
}