Public Member Functions | Static Public Member Functions | Static Public Attributes | List of all members
RexxQueue Class Reference

#include <QueueClass.hpp>

Inheritance diagram for RexxQueue:
[legend]

Public Member Functions

void * operator new (size_t)
 
void * operator new (size_t size, void *ptr)
 
 RexxQueue ()
 
 RexxQueue (RESTORETYPE restoreType)
 
RexxObject * pullRexx ()
 
RexxObject * pushRexx (RexxObject *)
 
RexxObject * queueRexx (RexxObject *)
 
LISTENTRY * locateEntry (RexxObject *, RexxObject *)
 
RexxObject * put (RexxObject *, RexxObject *)
 
RexxObject * at (RexxObject *)
 
RexxObject * remove (RexxObject *)
 
RexxObject * hasindex (RexxObject *)
 
RexxObject * peek ()
 
RexxObject * supplier ()
 
RexxObject * newRexx (RexxObject **, size_t, size_t)
 
RexxQueue * ofRexx (RexxObject **, size_t, size_t)
 
RexxObject * append (RexxObject *)
 
RexxArray * allIndexes ()
 
RexxObject * index (RexxObject *)
 
RexxObject * firstRexx ()
 
RexxObject * lastRexx ()
 
RexxObject * next (RexxObject *)
 
RexxObject * previous (RexxObject *)
 
size_t entryToIndex (size_t target)
 
RexxObject * insert (RexxObject *, RexxObject *)
 
RexxObject * section (RexxObject *, RexxObject *)
 
RexxObject * sectionSubclass (LISTENTRY *, size_t)
 
RexxObject * pop ()
 
void push (RexxObject *obj)
 
void queue (RexxObject *obj)
 
- Public Member Functions inherited from RexxList
void * operator new (size_t)
 
void * operator new (size_t size, void *objectPtr)
 
 RexxList (RESTORETYPE restoreType)
 
 RexxList ()
 
void init ()
 
void live (size_t)
 
void liveGeneral (int reason)
 
void flatten (RexxEnvelope *)
 
RexxObject * copy ()
 
RexxArray * makeArray ()
 
RexxArray * allItems ()
 
RexxArray * allIndexes ()
 
RexxArray * requestArray ()
 
RexxObject * value (RexxObject *)
 
RexxObject * remove (RexxObject *)
 
RexxObject * primitiveRemove (LISTENTRY *)
 
size_t firstIndex ()
 
size_t lastIndex ()
 
size_t nextIndex (size_t i)
 
size_t previousIndex (size_t i)
 
RexxObject * getValue (size_t i)
 
RexxObject * firstRexx ()
 
RexxObject * lastRexx ()
 
RexxObject * next (RexxObject *)
 
RexxObject * previous (RexxObject *)
 
RexxObject * hasIndex (RexxObject *)
 
RexxSupplier * supplier ()
 
RexxObject * itemsRexx ()
 
size_t items ()
 
RexxObject * insert (RexxObject *, RexxObject *)
 
RexxObject * put (RexxObject *, RexxObject *)
 
RexxObject * section (RexxObject *, RexxObject *)
 
RexxObject * sectionSubclass (LISTENTRY *, size_t)
 
RexxObject * firstItem ()
 
RexxObject * lastItem ()
 
RexxObject * insertRexx (RexxObject *, RexxObject *)
 
void partitionBuffer (size_t, size_t)
 
RexxArray * makeArrayIndices ()
 
size_t getFree ()
 
RexxObject * add (RexxObject *, RexxObject *)
 
RexxObject * removeFirst ()
 
RexxObject * removeLast ()
 
RexxObject * removeFirstItem ()
 
RexxObject * removeLastItem ()
 
RexxObject * removeIndex (size_t i)
 
LISTENTRY * getEntry (RexxObject *, RexxObject *)
 
LISTENTRY * getEntry (size_t)
 
RexxObject * indexOfValue (RexxObject *)
 
RexxObject * empty ()
 
RexxObject * isEmpty ()
 
RexxObject * index (RexxObject *)
 
RexxObject * hasItem (RexxObject *)
 
RexxObject * removeItem (RexxObject *)
 
RexxObject * removeObject (RexxObject *)
 
void addLast (RexxObject *value)
 
void addFirst (RexxObject *value)
 
size_t getSize ()
 
RexxObject * append (RexxObject *)
 
RexxArray * weakReferenceArray ()
 
RexxList * newRexx (RexxObject **, size_t, size_t)
 
RexxList * classOf (RexxObject **, size_t, size_t)
 
- Public Member Functions inherited from RexxObject
void * operator new (size_t, RexxClass *)
 
void * operator new (size_t, RexxClass *, RexxObject **, size_t, size_t)
 
void * operator new (size_t size, void *objectPtr)
 
void operator delete (void *, void *)
 
void operator delete (void *)
 
void operator delete (void *, RexxClass *)
 
void operator delete (void *, RexxClass *, RexxObject **, size_t)
 
RexxObject * newRexx (RexxObject **arguments, size_t argCount, size_t named_argCount)
 
RexxObject * newObject ()
 
 operator RexxInternalObject * ()
 
 RexxObject ()
 
 RexxObject (RESTORETYPE restoreType)
 
void initializeNewObject (size_t size, size_t mark, void *vft, RexxBehaviour *b)
 
void initializeNewObject (size_t mark, void *vft, RexxBehaviour *b)
 
virtual ~RexxObject ()
 
virtual RexxObject * defMethod (RexxString *, RexxMethod *, RexxString *a=OREF_NULL)
 
virtual RexxString * defaultName ()
 
virtual RexxObject * unknown (RexxString *msg, RexxArray *args, RexxDirectory *named_args)
 
virtual RexxInteger * hasMethod (RexxString *msg)
 
bool hasUninitMethod ()
 
RexxObject * init ()
 
void uninit ()
 
HashCode hash ()
 
bool truthValue (int)
 
virtual bool logicalValue (logical_t &)
 
virtual bool numberValue (wholenumber_t &result, size_t precision)
 
virtual bool numberValue (wholenumber_t &result)
 
virtual bool unsignedNumberValue (stringsize_t &result, size_t precision)
 
virtual bool unsignedNumberValue (stringsize_t &result)
 
virtual bool doubleValue (double &result)
 
RexxNumberString * numberString ()
 
RexxInteger * integerValue (size_t)
 
RexxString * makeString ()
 
RexxText * makeText ()
 
void copyIntoTail (RexxCompoundTail *buffer)
 
RexxString * stringValue ()
 
RexxText * textValue ()
 
RexxString * requestString ()
 
RexxString * requestStringNoNOSTRING ()
 
RexxText * requestText ()
 
RexxInteger * requestInteger (size_t)
 
bool requestNumber (wholenumber_t &, size_t)
 
bool requestUnsignedNumber (stringsize_t &, size_t)
 
RexxArray * requestArray ()
 
RexxDirectory * requestDirectory ()
 
RexxString * requiredString (RexxString *kind, size_t)
 
RexxString * requiredString (RexxString *kind, const char *)
 
RexxString * requiredString ()
 
RexxInteger * requiredInteger (RexxString *kind, size_t, size_t)
 
wholenumber_t requiredNumber (RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
 
stringsize_t requiredPositive (RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
 
stringsize_t requiredNonNegative (RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
 
bool isEqual (RexxObject *)
 
bool isInstanceOf (RexxClass *)
 
RexxObject * isInstanceOfRexx (RexxClass *)
 
RexxObject * isNilRexx ()
 
RexxMethod * instanceMethod (RexxString *)
 
RexxSupplier * instanceMethods (RexxClass *)
 
RexxMethod * instanceMethodRexx (RexxString *)
 
RexxSupplier * instanceMethodsRexx (RexxClass *)
 
RexxObject * dynamicTargetRexx (RexxObject **arguments, size_t argCount, size_t named_argCount)
 
RexxString * objectName ()
 
RexxObject * objectNameEquals (RexxObject *)
 
RexxClass * classObject ()
 
RexxObject * setMethod (RexxString *, RexxMethod *, RexxString *a=OREF_NULL)
 
RexxObject * unsetMethod (RexxString *)
 
RexxObject * requestRexx (RexxString *)
 
RexxMessage * start (RexxObject **, size_t, size_t)
 
RexxMessage * startWith (RexxObject *, RexxArray *, RexxObject **, size_t)
 
RexxObject * send (RexxObject **, size_t, size_t)
 
RexxObject * sendWith (RexxObject *, RexxArray *, RexxObject **, size_t)
 
RexxMessage * startCommon (RexxObject *message, RexxObject **arguments, size_t argCount, size_t named_argCount)
 
RexxString * oref ()
 
RexxObject * pmdict ()
 
RexxObject * run (RexxObject **, size_t, size_t)
 
bool messageSend (RexxString *, RexxObject **, size_t, size_t, ProtectedObject &, bool processUnknown=true, bool dynamicTarget=true)
 
bool messageSend (RexxString *, RexxObject **, size_t, size_t, RexxObject *, ProtectedObject &, bool processUnknown=true, bool dynamicTarget=true)
 
RexxMethod * checkPrivate (RexxMethod *, RexxErrorCodes &)
 
RexxMethod * checkPackage (RexxMethod *, RexxErrorCodes &)
 
void processUnknown (RexxErrorCodes, RexxString *, RexxObject **, size_t, size_t, ProtectedObject &)
 
void processProtectedMethod (RexxString *, RexxMethod *, RexxObject **, size_t, size_t, ProtectedObject &)
 
void sendMessage (RexxString *, RexxArray *, RexxDirectory *, ProtectedObject &)
 
void sendMessage (RexxString *message, RexxObject **args, size_t argCount, size_t named_argCount, ProtectedObject &result)
 
void sendMessage (RexxString *message, ProtectedObject &result)
 
void sendMessage (RexxString *message, RexxObject *argument1, ProtectedObject &result)
 
void sendMessage (RexxString *, RexxObject *, RexxObject *, ProtectedObject &)
 
void sendMessage (RexxString *, RexxObject *, RexxObject *, RexxObject *, ProtectedObject &)
 
void sendMessage (RexxString *, RexxObject *, RexxObject *, RexxObject *, RexxObject *, ProtectedObject &)
 
void sendMessage (RexxString *, RexxObject *, RexxObject *, RexxObject *, RexxObject *, RexxObject *, ProtectedObject &)
 
RexxObject * sendMessage (RexxString *, RexxArray *, RexxDirectory *=OREF_NULL)
 
RexxObject * sendMessage (RexxString *message, RexxObject **args, size_t argCount, size_t named_argCount)
 
RexxObject * sendMessage (RexxString *message)
 
RexxObject * sendMessage (RexxString *message, RexxObject *argument1)
 
RexxObject * sendMessage (RexxString *, RexxObject *, RexxObject *)
 
RexxObject * sendMessage (RexxString *, RexxObject *, RexxObject *, RexxObject *)
 
RexxObject * sendMessage (RexxString *, RexxObject *, RexxObject *, RexxObject *, RexxObject *)
 
RexxObject * sendMessage (RexxString *, RexxObject *, RexxObject *, RexxObject *, RexxObject *, RexxObject *)
 
RexxObject * defMethods (RexxDirectory *)
 
void setObjectVariable (RexxString *, RexxObject *, RexxObject *)
 
RexxObject * getObjectVariable (RexxString *)
 
RexxObject * getObjectVariable (RexxString *, RexxObject *)
 
void addObjectVariables (RexxVariableDictionary *)
 
void copyObjectVariables (RexxObject *newObject)
 
RexxObject * superScope (RexxObject *)
 
RexxMethod * superMethod (RexxString *, RexxObject *)
 
RexxObject * mdict ()
 
RexxObject * setMdict (RexxObject *)
 
RexxBehaviour * behaviourObject ()
 
const char * idString ()
 
RexxString * id ()
 
RexxMethod * methodLookup (RexxString *name)
 
RexxVariableDictionary * getObjectVariables (RexxObject *)
 
void guardOn (RexxActivity *activity, RexxObject *scope)
 
void guardOff (RexxActivity *activity, RexxObject *scope)
 
RexxObject * equal (RexxObject *)
 
RexxObject * notEqual (RexxObject *other)
 
RexxObject * strictEqual (RexxObject *)
 
RexxObject * strictNotEqual (RexxObject *other)
 
RexxInteger * identityHashRexx ()
 
RexxObject * hashCode ()
 
RexxString * stringRexx ()
 
RexxString * concatRexx (RexxObject *)
 
RexxString * concatBlank (RexxObject *)
 
RexxObject * makeStringRexx ()
 
RexxObject * makeArrayRexx ()
 
RexxString * defaultNameRexx ()
 
RexxObject * copyRexx ()
 
RexxObject * unknownRexx (RexxString *, RexxArray *, RexxObject **, size_t)
 
RexxObject * hasMethodRexx (RexxString *)
 
void * getCSelf ()
 
void * getCSelf (RexxObject *scope)
 
bool equalValue (RexxObject *other)
 
virtual wholenumber_t compareTo (RexxObject *)
 
 koper (operator_plus) koper(operator_minus) koper(operator_multiply) koper(operator_divide) koper(operator_integerDivide) koper(operator_remainder) koper(operator_power) koper(operator_abuttal) koper(operator_concat) koper(operator_concatBlank) koper(operator_equal) koper(operator_notEqual) koper(operator_isGreaterThan) koper(operator_isBackslashGreaterThan) koper(operator_isLessThan) koper(operator_isBackslashLessThan) koper(operator_isGreaterOrEqual) koper(operator_isLessOrEqual) koper(operator_strictEqual) koper(operator_strictNotEqual) koper(operator_strictGreaterThan) koper(operator_strictBackslashGreaterThan) koper(operator_strictLessThan) koper(operator_strictBackslashLessThan) koper(operator_strictGreaterOrEqual) koper(operator_strictLessOrEqual) koper(operator_lessThanGreaterThan) koper(operator_greaterThanLessThan) koper(operator_and) koper(operator_or) koper(operator_xor) koper(operator_not) RexxVariableDictionary *objectVariables
 
- Public Member Functions inherited from RexxInternalObject
void * operator new (size_t, RexxClass *)
 
void * operator new (size_t, RexxClass *, RexxObject **, size_t, size_t)
 
void * operator new (size_t size, void *ptr)
 
void operator delete (void *)
 
void operator delete (void *p, void *ptr)
 
 RexxInternalObject ()
 
 RexxInternalObject (RESTORETYPE restoreType)
 
virtual ~RexxInternalObject ()
 
 operator RexxObject * ()
 
size_t getObjectSize ()
 
void setObjectSize (size_t s)
 
size_t getObjectDataSize ()
 
void * getObjectDataSpace ()
 
void clearObject ()
 
void clearObject (size_t l)
 
void setVirtualFunctions (void *t)
 
void setInitHeader (size_t s, size_t markword)
 
void setInitHeader (size_t markword)
 
void setObjectLive (size_t markword)
 
void setHasReferences ()
 
void setHasNoReferences ()
 
bool hasReferences ()
 
bool hasNoReferences ()
 
void setPrimitive ()
 
void setNonPrimitive ()
 
bool isPrimitive ()
 
bool isNonPrimitive ()
 
void setInRexxPackage ()
 
bool isInRexxPackage ()
 
bool isObjectMarked (size_t markword)
 
void setObjectMark (size_t markword)
 
void clearObjectMark ()
 
bool isObjectLive (size_t mark)
 
bool isObjectDead (size_t mark)
 
bool isOldSpace ()
 
bool isNewSpace ()
 
void setNewSpace ()
 
void setOldSpace ()
 
void makeProxiedObject ()
 
bool isProxyObject ()
 
bool isSubClassOrEnhanced ()
 
bool isBaseClass ()
 
size_t getObjectTypeNumber ()
 
RexxBehaviour * getObjectType ()
 
bool isObjectType (RexxBehaviour *b)
 
bool isObjectType (size_t t)
 
bool isSameType (RexxInternalObject *o)
 
void setBehaviour (RexxBehaviour *b)
 
virtual RexxObject * makeProxy (RexxEnvelope *)
 
virtual RexxObject * evaluate (RexxActivation *, RexxExpressionStack *)
 
virtual RexxObject * getValue (RexxActivation *)
 
virtual RexxObject * getValue (RexxVariableDictionary *)
 
virtual RexxObject * getRealValue (RexxActivation *)
 
virtual RexxObject * getRealValue (RexxVariableDictionary *)
 
virtual HashCode getHashValue ()
 
HashCode identityHash ()
 
virtual RexxString * primitiveMakeString ()
 
virtual RexxText * primitiveMakeText ()
 
virtual RexxObject * dynamicTarget (RexxObject **arguments, size_t count, size_t named_count)
 
void hasUninit ()
 
void removedUninit ()
 
void printObject ()
 
RexxObject * clone ()
 
- Public Member Functions inherited from RexxVirtualBase
virtual RexxObject * unflatten (RexxEnvelope *)
 

Static Public Member Functions

static void createInstance ()
 
- Static Public Member Functions inherited from RexxList
static void createInstance ()
 
- Static Public Member Functions inherited from RexxObject
static void decodeMessageName (RexxObject *target, RexxObject *message, RexxString *&messageName, RexxObject *&startScope)
 
static void createInstance ()
 
- Static Public Member Functions inherited from RexxInternalObject
static size_t getObjectHeaderSize ()
 

Static Public Attributes

static RexxClass * classInstance = OREF_NULL
 
- Static Public Attributes inherited from RexxList
static RexxClass * classInstance = OREF_NULL
 
- Static Public Attributes inherited from RexxObject
static PCPPM operatorMethods []
 
static RexxClass * classInstance = OREF_NULL
 

Additional Inherited Members

- Public Attributes inherited from RexxInternalObject
ObjectHeader header
 
RexxBehaviour * behaviour
 
- Protected Member Functions inherited from RexxVirtualBase
virtual ~RexxVirtualBase ()
 
virtual void baseVirtual ()
 
- Protected Attributes inherited from RexxList
RexxListTable * table
 
size_t first
 
size_t last
 
size_t count
 
size_t size
 
size_t free
 

Detailed Description

Definition at line 49 of file QueueClass.hpp.

Constructor & Destructor Documentation

◆ RexxQueue() [1/2]

RexxQueue::RexxQueue ( )
inline

Definition at line 54 of file QueueClass.hpp.

Referenced by newRexx(), ofRexx(), and section().

◆ RexxQueue() [2/2]

RexxQueue::RexxQueue ( RESTORETYPE  restoreType)
inline

Definition at line 55 of file QueueClass.hpp.

Member Function Documentation

◆ allIndexes()

RexxArray * RexxQueue::allIndexes ( void  )

Retrieve an array containing all index values for the queue. For queue classes, the indices are the integers 1 - items(), so this is generally a pretty silly way to access this.

Returns
An array containing all of the queue indices.

Definition at line 345 of file QueueClass.cpp.

References RexxList::items(), new_array(), new_integer(), and RexxArray::put().

Referenced by RexxMemory::createImage().

◆ append()

RexxObject * RexxQueue::append ( RexxObject *  item)

Append an item after the last item in the list.

Parameters
valueThe value to append.
Returns
The index of the appended item.

Definition at line 99 of file QueueClass.cpp.

References ARG_ONE, RexxList::count, new_integer(), queue(), and requiredArgument().

Referenced by RexxMemory::createImage().

◆ at()

RexxObject * RexxQueue::at ( RexxObject *  _index)

Definition at line 181 of file QueueClass.cpp.

References IntegerOne, locateEntry(), OREF_NULL, TheNilObject, and listentry::value.

Referenced by RexxMemory::createImage().

◆ createInstance()

void RexxQueue::createInstance ( )
static

Create initial class object at bootstrap time.

Definition at line 58 of file QueueClass.cpp.

References CLASS_CREATE.

Referenced by RexxMemory::createImage().

◆ entryToIndex()

size_t RexxQueue::entryToIndex ( size_t  target)

Convert an entry index into a queue index relative to the beginning.

Parameters
targetThe target index position.
Returns
The queue index value.

Definition at line 486 of file QueueClass.cpp.

References ENTRY_POINTER, RexxList::first, and LIST_END.

Referenced by insert(), next(), and previous().

◆ firstRexx()

RexxObject * RexxQueue::firstRexx ( void  )

Definition at line 393 of file QueueClass.cpp.

References RexxList::first, IntegerOne, LIST_END, and TheNilObject.

Referenced by RexxMemory::createImage().

◆ hasindex()

RexxObject * RexxQueue::hasindex ( RexxObject *  _index)

Definition at line 305 of file QueueClass.cpp.

References IntegerOne, locateEntry(), TheFalseObject, and TheTrueObject.

Referenced by RexxMemory::createImage().

◆ index()

RexxObject * RexxQueue::index ( RexxObject *  target)

Return the index of the first item with a matching value in the list. Returns .nil if the object is not found.

Parameters
targetThe target object.
Returns
The index of the item, or .nil.

Definition at line 370 of file QueueClass.cpp.

References ARG_ONE, RexxList::count, ENTRY_POINTER, RexxObject::equalValue(), RexxList::first, new_integer(), listentry::next, requiredArgument(), TheNilObject, and listentry::value.

Referenced by RexxMemory::createImage().

◆ insert()

RexxObject * RexxQueue::insert ( RexxObject *  _value,
RexxObject *  _index 
)

Insert an item into the queue at a specific index position.

Parameters
valueThe value to insert.
indexThe index. This can be omitted, which inserts at the end, .nil which inserts at the beginning, or a valid existing index.
Returns
The inserted object's index.

Definition at line 211 of file QueueClass.cpp.

References ARG_ONE, RexxList::count, ENTRY_INDEX, ENTRY_POINTER, entryToIndex(), Error_Incorrect_method_queue_index, RexxList::first, RexxList::getFree(), IntegerTwo, RexxList::last, LIST_END, locateEntry(), new_integer(), listentry::next, OREF_NULL, OrefSet, listentry::previous, reportException(), requiredArgument(), RexxList::table, TheNilObject, and listentry::value.

Referenced by RexxMemory::createImage().

◆ lastRexx()

RexxObject * RexxQueue::lastRexx ( void  )

Definition at line 410 of file QueueClass.cpp.

References RexxList::items(), RexxList::last, LIST_END, new_integer(), and TheNilObject.

Referenced by RexxMemory::createImage().

◆ locateEntry()

LISTENTRY * RexxQueue::locateEntry ( RexxObject *  _index,
RexxObject *  position 
)

Definition at line 121 of file QueueClass.cpp.

References ENTRY_POINTER, Error_Incorrect_method_noarg, Error_Incorrect_method_queue_index, RexxList::first, LIST_END, OREF_NULL, reportException(), REQUEST_INTEGER(), TheNilObject, and RexxInteger::wholeNumber().

Referenced by at(), hasindex(), insert(), next(), previous(), put(), remove(), and section().

◆ newRexx()

RexxObject * RexxQueue::newRexx ( RexxObject **  init_args,
size_t  argCount,
size_t  named_argCount 
)

Definition at line 586 of file QueueClass.cpp.

References RexxClass::checkAbstract(), RexxClass::getInstanceBehaviour(), RexxInternalObject::hasUninit(), RexxClass::hasUninitDefined(), RexxQueue(), RexxObject::sendMessage(), and RexxInternalObject::setBehaviour().

Referenced by RexxMemory::createImage().

◆ next()

RexxObject * RexxQueue::next ( RexxObject *  _index)

Definition at line 427 of file QueueClass.cpp.

References entryToIndex(), Error_Incorrect_method_queue_index, IntegerOne, LIST_END, locateEntry(), new_integer(), listentry::next, reportException(), and TheNilObject.

Referenced by RexxMemory::createImage().

◆ ofRexx()

RexxQueue * RexxQueue::ofRexx ( RexxObject **  args,
size_t  argCount,
size_t  named_argCount 
)

Definition at line 611 of file QueueClass.cpp.

References RexxList::addLast(), Error_Incorrect_method_noarg, OREF_NULL, reportException(), RexxQueue(), RexxObject::sendMessage(), and TheQueueClass.

Referenced by RexxMemory::createImage().

◆ operator new() [1/2]

void* RexxQueue::operator new ( size_t  size,
void *  ptr 
)
inline

Definition at line 53 of file QueueClass.hpp.

◆ operator new() [2/2]

void * RexxQueue::operator new ( size_t  size)

Definition at line 666 of file QueueClass.cpp.

References RexxList::init(), INITIAL_LIST_SIZE, RexxInternalObject::setBehaviour(), and TheQueueBehaviour.

◆ peek()

RexxObject * RexxQueue::peek ( )

Definition at line 317 of file QueueClass.cpp.

References RexxList::firstItem().

Referenced by RexxMemory::createImage(), RexxSource::topDo(), and RexxSource::topOperator().

◆ pop()

RexxObject* RexxQueue::pop ( )
inline

Definition at line 80 of file QueueClass.hpp.

References RexxList::removeFirst().

Referenced by RexxSource::argArray(), RexxSource::argList(), RexxSource::parseLogical(), RexxSource::popNTerms(), RexxSource::popSubTerm(), RexxSource::popTerm(), pullRexx(), RexxCompoundVariable::RexxCompoundVariable(), RexxExpressionFunction::RexxExpressionFunction(), RexxExpressionLogical::RexxExpressionLogical(), RexxExpressionMessage::RexxExpressionMessage(), RexxInstructionCall::RexxInstructionCall(), RexxInstructionDrop::RexxInstructionDrop(), RexxInstructionExpose::RexxInstructionExpose(), RexxInstructionParse::RexxInstructionParse(), RexxInstructionProcedure::RexxInstructionProcedure(), RexxInstructionRaise::RexxInstructionRaise(), RexxInstructionUpper::RexxInstructionUpper(), RexxInstructionUseStrict::RexxInstructionUseStrict(), RexxTrigger::RexxTrigger(), and RexxSource::words().

◆ previous()

RexxObject * RexxQueue::previous ( RexxObject *  _index)

Definition at line 453 of file QueueClass.cpp.

References entryToIndex(), Error_Incorrect_method_queue_index, IntegerOne, LIST_END, locateEntry(), new_integer(), listentry::previous, reportException(), and TheNilObject.

Referenced by RexxMemory::createImage().

◆ pullRexx()

RexxObject * RexxQueue::pullRexx ( )

Definition at line 64 of file QueueClass.cpp.

References OREF_NULL, pop(), and TheNilObject.

Referenced by RexxMemory::createImage(), RexxInstructionSelect::matchEnd(), RexxActivation::mergeTraps(), RexxSource::popDo(), RexxSource::popOperator(), and RexxActivation::processTraps().

◆ push()

void RexxQueue::push ( RexxObject *  obj)
inline

Definition at line 81 of file QueueClass.hpp.

References RexxList::addFirst().

Referenced by RexxSource::addCompound(), RexxSource::argList(), build(), RexxVariableDictionary::buildCompoundVariable(), RexxSource::parseNew(), RexxSource::processVariableList(), pushRexx(), RexxSource::pushSubTerm(), RexxSource::pushTerm(), RexxSource::raiseNew(), RexxSource::useNew(), and RexxSource::words().

◆ pushRexx()

RexxObject * RexxQueue::pushRexx ( RexxObject *  item)

Definition at line 78 of file QueueClass.cpp.

References ARG_ONE, OREF_NULL, push(), and requiredArgument().

Referenced by RexxInstructionSelect::addWhen(), RexxMemory::createImage(), RexxSource::pushDo(), and RexxSource::pushOperator().

◆ put()

RexxObject * RexxQueue::put ( RexxObject *  _value,
RexxObject *  _index 
)

Definition at line 162 of file QueueClass.cpp.

References ARG_ONE, Error_Incorrect_method_queue_index, IntegerTwo, locateEntry(), OREF_NULL, OrefSet, reportException(), requiredArgument(), RexxList::table, and listentry::value.

Referenced by RexxMemory::createImage().

◆ queue()

void RexxQueue::queue ( RexxObject *  obj)
inline

Definition at line 82 of file QueueClass.hpp.

References RexxList::addLast().

Referenced by append(), StringUtil::makearray(), RexxSource::processVariableList(), queueRexx(), and RexxSource::raiseNew().

◆ queueRexx()

RexxObject * RexxQueue::queueRexx ( RexxObject *  item)

Definition at line 109 of file QueueClass.cpp.

References ARG_ONE, OREF_NULL, queue(), and requiredArgument().

Referenced by RexxMemory::createImage().

◆ remove()

RexxObject * RexxQueue::remove ( RexxObject *  _index)

Definition at line 294 of file QueueClass.cpp.

References IntegerOne, locateEntry(), and RexxList::primitiveRemove().

Referenced by RexxMemory::createImage().

◆ section()

RexxObject * RexxQueue::section ( RexxObject *  _index,
RexxObject *  _count 
)

Create a sublist of this queue.

Parameters
_indexThe starting index
_countThe size of the subset to extract.
Returns
A new instance of this class containing the subsection items.

Definition at line 512 of file QueueClass.cpp.

References RexxList::addLast(), ARG_TWO, ENTRY_POINTER, Error_Incorrect_method_index, IntegerOne, isOfClass, LIST_END, locateEntry(), listentry::next, OREF_NULL, reportException(), RexxObject::requiredNonNegative(), RexxQueue(), sectionSubclass(), and listentry::value.

Referenced by RexxMemory::createImage().

◆ sectionSubclass()

RexxObject * RexxQueue::sectionSubclass ( LISTENTRY *  element,
size_t  counter 
)

Section method used when dealing with a subclass of the Queue class.

Parameters
elementThe starting element.
counterthe number of items to extract.
Returns
A new instance of the target class containing the subsection elements.

Definition at line 563 of file QueueClass.cpp.

References RexxInternalObject::behaviour, ENTRY_POINTER, RexxBehaviour::getOwningClass(), LIST_END, listentry::next, RexxObject::sendMessage(), and listentry::value.

Referenced by section().

◆ supplier()

RexxObject * RexxQueue::supplier ( void  )

Definition at line 326 of file QueueClass.cpp.

References RexxList::makeArray(), new_supplier(), and OREF_NULL.

Referenced by RexxMemory::createImage().

Member Data Documentation

◆ classInstance

RexxClass * RexxQueue::classInstance = OREF_NULL
static

Definition at line 85 of file QueueClass.hpp.

The documentation for this class was generated from the following files: