/** * Perform an interpret call where we want to return a container that * contains flattened containers (flattened by 1). * * @param environment Not used. * @param parms The parameters passed to the builtin function. * @param additional_parameter Not used. * @return a container of elements. * * @version * - JR Lewis 2012.06.01 * - Initial version. */ Element ConcatBuiltinImplementation::Interpret_( Environment& /* environment */ , std::vector<Element> const& parms , Element const& /* additional_parameter */ ) { typedef std::vector<Element>::const_iterator Iterator; Container C; Iterator iter = parms.begin(); Iterator end = parms.end(); for(; iter != end; ++iter) { bool isAContainer = false; Container current = CastToContainer(*iter, isAContainer); if (isAContainer) { int const NUMBER_OF_ELEMENTS = current.NumberOfElements(); for(int i=0; i<NUMBER_OF_ELEMENTS; ++i) { C.Add(current.Get(i)); } } else { C.Add(*iter); } } return C; }
static void CreateBitmapWindow(Container& owner, TitleBitmapWindow*& bitmap, /*IceGroupBox*& group,*/ TitleWindow* parent, sdword x, sdword y, udword width, udword height, const char* label) { const udword OffsetY = 4; // ### not sure why this is needed // Create bitmap window WindowDesc WD; WD.mParent = parent; WD.mX = x + GROUP_BOX_BORDER_SIZE; WD.mY = y + GROUP_BOX_BORDER_SIZE + OffsetY; WD.mWidth = width; WD.mHeight = height; WD.mLabel = "BitmapWindow"; WD.mType = WINDOW_POPUP; WD.mStyle = WSTYLE_NORMAL; // ### the better style works but not all pixels get displayed // WD.mStyle = WSTYLE_CLIENT_EDGES|WSTYLE_STATIC_EDGES; bitmap = ICE_NEW(TitleBitmapWindow)(WD); bitmap->SetVisible(true); bitmap->mMainW = parent; owner.Add(udword(bitmap)); /* if(0) { GroupBoxDesc GBD; GBD.mParent = parent; GBD.mX = x; GBD.mY = y; GBD.mWidth = width + GROUP_BOX_BORDER_SIZE*2; GBD.mHeight = height + GROUP_BOX_BORDER_SIZE*2 + OffsetY; GBD.mLabel = label; group = ICE_NEW(IceGroupBox)(GBD); owner.Add(udword(group)); } else*/ { EditBoxDesc EBD; EBD.mParent = parent; EBD.mX = x; EBD.mY = y; EBD.mWidth = width + GROUP_BOX_BORDER_SIZE*2; EBD.mHeight = height + GROUP_BOX_BORDER_SIZE*2 + OffsetY; EBD.mLabel = label; EBD.mFilter = EDITBOX_TEXT; EBD.mType = EDITBOX_READ_ONLY; IceEditBox* EB = ICE_NEW(IceEditBox)(EBD); EB->SetVisible(true); owner.Add(udword(EB)); } }
STATUS UserManager::EnumTableReplyHandler( void*, STATUS ){ UserAccessTableEntry *pRow = (UserAccessTableEntry *)m_pTemp; User *pUser; Container *pContainer; if( m_shouldReinit ){ m_shouldReinit = false; delete m_pTemp; return m_pUserTable->Enumerate( &m_pTemp, (pTSCallback_t)METHOD_ADDRESS( UserManager, EnumTableReplyHandler ), NULL ); } pContainer = new SList; for( U32 index = 0; index < m_pUserTable->GetNumberOfRows(); index++, pRow++ ){ pUser = new User( GetListenManager() ); pUser->BuildYourselfFromPtsRow( pRow ); pUser->m_pUserManager = this; pContainer->Add( (CONTAINER_ELEMENT)pUser ); } AddObjectsIntoManagedObjectsVector( *pContainer ); delete m_pTemp; delete pContainer; m_isIniting = m_shouldReinit = false; SSAPI_TRACE( TRACE_L2, "\nUserManager: ...Done! Objects built: ", GetManagedObjectCount() ); SetIsReadyToServiceRequests( true ); return OK; }
void PropertyRestrictions<Key, KeyValue, Container>::ConfigureFromJsonAndKey( const Configuration * inputJson, const std::string& key ) { // Make this optional. if( inputJson->Exist( key ) == false ) { return; } // We have a list of json objects. The format/logic is as follows. For input: // [ // { "Character": "Good", "Income": "High" }, // { "Character": "Bad", "Income": "Low" } // ] // We give the intervention if the individuals has // Good Character AND High Income OR Bad Character AND Low Income. // So we AND together the elements of each json object and OR together these // calculated truth values of the elements of the json array. json::QuickInterpreter s2sarray = (*inputJson)[key].As<json::Array>(); for( int idx=0; idx < (*inputJson)[key].As<json::Array>().Size(); idx++ ) { Container container; auto json_map = s2sarray[idx].As<json::Object>(); for( auto data = json_map.Begin(); data != json_map.End(); ++data ) { std::string key = data->name; std::string value = (std::string)s2sarray[idx][key].As< json::String >(); KeyValue kv( key, value ); container.Add( kv ); } _restrictions.push_back( container ); } }
/** * The following method takes the path and elements passed in and creates a * new ExecutorProcess_ element that will be in charge of running the * program. * * @version * - JR Lewis 2012.03.05 * - Initial version. */ Element ExecutorBuiltinImplementation::InterpretParsed_( Environment& environment , Element& path_element , std::vector<Element> const& parms) { String_* path = dynamic_cast<String_*>(path_element.ElementHandle()); Element out; std::vector<Element> parameters; Funcall_::InterpretParameters( environment , parms , parameters ); if ( 0 != path ) { Container container; size_t const PARMS_SIZE = parameters.size(); for(size_t i=0; i<PARMS_SIZE; ++i) { container.Add(parameters[i]); } ExecutorProcessing_* processing = new ExecutorProcessing_( this->strine , QString::fromStdString(path->Value()) , container); out = Processing(processing); } return out; }
void PropertyRestrictions<Key, KeyValue, Container>::Add( std::map< std::string, std::string >& rMap ) { Container container; for( auto& entry : rMap ) { KeyValue kv( entry.first, entry.second ); container.Add( kv ); } _restrictions.push_back( container ); }
Element InterpretContainer_( Container container , Environment& , std::vector<Element> const& elements) { Container newContainer = container.Copy(); size_t const SIZE = elements.size(); for(size_t i=0; i<SIZE; ++i) { newContainer.Add(elements[i]); } return newContainer; }
Element FileAttributesBuiltinImplementation::Interpret_( Environment& , std::vector<strine::Element> const& parms , Element const& ) { Container out; QString filename; if (1 >= parms.size()) { bool success = false; String s = CastToString(parms[0], success); if (success) { filename = QString::fromStdString(s.Value()); } } QFileInfo fileInfo(filename); if (fileInfo.isReadable()) { out.Add(String("read")); } if (fileInfo.isWritable()) { out.Add(String("write")); } if (fileInfo.isExecutable()) { out.Add(String("execute")); } if (fileInfo.isDir()) { out.Add(String("directory")); } if (fileInfo.isHidden()) { out.Add(String("hidden")); } if (fileInfo.isSymLink()) { out.Add(String("link")); } out.Add(String(fileInfo.owner().toStdString())); return out; }
void RayCollider::_UnboundedStab(const AABBTreeNode* node, Container& box_indices) { // Test the box against the ray Point Center, Extents; node->GetAABB()->GetCenter(Center); node->GetAABB()->GetExtents(Extents); if(!RayAABBOverlap(Center, Extents)) return; if(node->IsLeaf()) { box_indices.Add(node->GetPrimitives(), node->GetNbPrimitives()); } else { _UnboundedStab(node->GetPos(), box_indices); _UnboundedStab(node->GetNeg(), box_indices); } }
STATUS UserManager::RowInsertedEventHandler( void *pRow, U32 rowCount, ShadowTable* ){ Container *pContainer; if( m_isIniting ){ m_shouldReinit = true; return OK; } User *pUser = new User( GetListenManager() ); pUser->BuildYourselfFromPtsRow( (UserAccessTableEntry *)pRow ); pUser->BuildYourValueSet(); pUser->m_pUserManager = this; pContainer = new SList; pContainer->Add( ( CONTAINER_ELEMENT )pUser ); AddObjectsIntoManagedObjectsVector( *pContainer ); delete pContainer; SetIsReadyToServiceRequests( true ); return OK; }
void StorageElementArray::ReportYourUnderlyingDevices( Container &devices ){ SList tempContainer; StorageElement *pElement; U32 index; DesignatorId *pId; devices.RemoveAll(); for( index = 0 ; index < GetChildCount(); index++ ){ // request a list for every child pElement = (StorageElement *)GetChild( index ); pElement->ReportYourUnderlyingDevices( tempContainer ); // move ids into the main vector while( tempContainer.Count() ){ tempContainer.GetAt( (CONTAINER_ELEMENT &)pId, 0 ); tempContainer.RemoveAt( 0 ); devices.Add( (CONTAINER_ELEMENT) pId ); } } }