Sorry your browser is not supported!

#include <vector>
using namespace std;


#include "../FoundationClasses/jfc_common.h"

//using std::vector;

//unsigned int size();            Returns the number of elements in a vector
//push_back(TYPE element);        Adds an element to the end of a vector
//swap(int x, int y);             Swap elements x and y
//bool empty();                   Returns true if the vector is empty
//void clear();                   Erase all elements of the vector




#include "DarkGDK.h"

// the main entry point for the application is this function
void DarkGDK ( void )
{

    vector <int> example;         //Vector to store integers
    example.push_back(3);         //Add 3 onto the vector
    example.push_back(10);        //Add 10 to the end
    example.push_back(33);        //Add 33 to the end
    for(int x=0; x<example.size(); x++) 
    {
        sprintf(JFC::CHAR1K,"%i ",example[x]);dbPrint(JFC::CHAR1K);    //Should output: 3 10 33
    } 
    if(!example.empty())          //Checks if empty
        example.clear();          //Clears vector
    vector <int> another_vector;  //Creates another vector to store integers
    another_vector.push_back(10); //Adds to end of vector
    example.push_back(10);        //Same
    if(example==another_vector)   //To show testing equality
    {
        example.push_back(20); 
    }
    for(int y=0; y<example.size(); y++)
    {
        sprintf(JFC::CHAR1K,"%i ",example[y]);dbPrint(JFC::CHAR1K);    //Should output: 3 10 33
    }




	while ( LoopGDK ( ) )
	{
    dbSync();
  };
};
    

------ Build started: Project: JegasLLC, Configuration: Debug Win32 ------
Linking...
libcpmtd.lib(xdebug.obj) : warning LNK4098: defaultlib 'libcmt.lib' conflicts with use of other libs; use /NODEFAULTLIB:library
Main_Test_StdLib.obj : error LNK2019: unresolved external symbol __CrtDbgReportW referenced in function "public: int & __thiscall std::vector<int,class std::allocator<int> >::operator[](unsigned int)" (??A?$vector@HV?$allocator@H@std@@@std@@QAEAAHI@Z)
libcpmtd.lib(stdthrow.obj) : error LNK2001: unresolved external symbol __CrtDbgReportW
libcpmtd.lib(xdebug.obj) : error LNK2019: unresolved external symbol __malloc_dbg referenced in function "void * __cdecl operator new(unsigned int,struct std::_DebugHeapTag_t const &,char *,int)" (??2@YAPAXIABU_DebugHeapTag_t@std@@PADH@Z)
libcpmtd.lib(xdebug.obj) : error LNK2019: unresolved external symbol __free_dbg referenced in function "void __cdecl operator delete(void *,struct std::_DebugHeapTag_t const &,char *,int)" (??3@YAXPAXABU_DebugHeapTag_t@std@@PADH@Z)
Debug\JegasLLC.exe : fatal error LNK1120: 3 unresolved externals
Build log was saved at "file://d:\files\code\CPP\Projects\JegasLLC\JegasLLC\Debug\BuildLog.htm"
JegasLLC - 5 error(s), 1 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2007 Jegas, LLC                      
============================================================================*/
#pragma once


#define cnAllocationSize 2 


//============================================================================
class JFC_AR{ 
//=============================================================================
  private:
    int Size;
    int Limit;
    int AllocationSize;

  public:
    JFC_AR();
    ~JFC_AR();
    int *ar; 
    
    int Size_Get(void);
    bool Size_Set(int p_Size);
    int Limit_Get(void);
    bool Limit_Set(int p_Limit);
    int AllocationSize_Get(void);
    bool AllocationSize_Set(int p_AllocationSize);
    bool Sort_Bubble(bool p_Ascending, bool p_SortEntireLimit);
    bool Flatten(void);
    bool AppendItem(void);
    bool InsertItem(int p_Position); // slow
    bool DeleteItem(int p_Position);// Slow
    bool DeleteAll(void);// Slow
};
//=============================================================================


//============================================================================
//============================================================================
//============================================================================

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2007 Jegas, LLC                      
============================================================================*/
#include "jfc_ar.h"
#include <memory.h>


//============================================================================
// Begin                            JFC_AR
//=============================================================================

//----------------------------------------------------------------------------
JFC_AR::JFC_AR(){
//----------------------------------------------------------------------------
  this->ar=0;
  this->Size=0;
  this->Limit=0;
  this->AllocationSize=cnAllocationSize;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
JFC_AR::~JFC_AR(){
//----------------------------------------------------------------------------
  if(this->ar!=0){ delete [] this->ar; };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JFC_AR::Size_Get(void){
//----------------------------------------------------------------------------
  return this->Size;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
bool JFC_AR::Size_Set(int p_Size){
//----------------------------------------------------------------------------
  bool bResult=(p_Size>-1);
  if(bResult){
    if(p_Size==0){
      this->Limit_Set(0);   
    }else{
      if(p_Size>Limit){
        int NewLimit = this->AllocationSize * (p_Size / this->AllocationSize);
        if((NewLimit==0) || ((p_Size % this->AllocationSize)!=0)){
          NewLimit+=this->AllocationSize;
        };
        this->Limit_Set(NewLimit);
      }else{
        // Shrinking?
        if(this->Size>p_Size){
          int i=0;
          // TODO: Make this wiping done via memset function.
          for(i=p_Size;i<this->Size;i++){
            this->ar[i]=0;
          };
        };
      };
    };
    this->Size=p_Size; 
  };
  return bResult;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JFC_AR::Limit_Get(void){
//----------------------------------------------------------------------------
  return this->Limit; 
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
bool JFC_AR::Limit_Set(int p_Limit){
//----------------------------------------------------------------------------
  bool bResult=((p_Limit>-1) && ((p_Limit % this->AllocationSize)==0));
  if(bResult){
    if(p_Limit==0){
      if(this->ar !=0){
        delete [] this->ar;
      };
      this->ar=0;
      this->Limit=0;
      this->Size=0;
    }else{
      int *arnew = new int [p_Limit];
      //memset(arnew, char(0), p_Limit * sizeof(int));
      int i=0;
      // TODO: Remove this for loop with memset function
      for(i=0;i<p_Limit;i++){
        arnew[i]=0;
      };
      if(this->ar !=0){
        //memcpy(arnew, this->ar, this->Size * sizeof(int));
        // TODO: implement memcpy routine
        for(i=0;i<this->Size;i++){
          arnew[i]=ar[i];
        };
        delete [] this->ar;
      };
      ar=arnew;
      this->Limit = p_Limit;
    };
  };
  return bResult;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int JFC_AR::AllocationSize_Get(void){
//----------------------------------------------------------------------------
  return this->AllocationSize;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
bool JFC_AR::AllocationSize_Set(int p_AllocationSize){
//----------------------------------------------------------------------------
  bool bResult=(this->Size==0) && (this->Limit==0) && (p_AllocationSize>0);
  if(bResult){
    this->AllocationSize=p_AllocationSize;   
  };
  return bResult;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Need At least two items for Sort to be successful. 
bool JFC_AR::Sort_Bubble(bool p_Ascending, bool p_SortEntireLimit){
//----------------------------------------------------------------------------
  int SortRange=0; 
  if(p_SortEntireLimit){
    SortRange=this->Limit;
  }else{
    SortRange=this->Size;
  };
  bool bResult=(this->ar!=0);
  if(bResult && (this->Size>1)){
    int t; int s; int iTemp;
    if(p_Ascending){
      // Redundant to avoid constant if p_Ascending then this else that
      for(s=0; s<SortRange; s++){
        for(t=0; t<SortRange-1; t++){
          if(  (this->ar[t])   > 
               (this->ar[t+1]) 
          ){
            iTemp=this->ar[t+1];
            this->ar[t+1]=this->ar[t];
            this->ar[t]=iTemp;
          };
        };
      };
    }else{
      // REdundant to avoid constant if p_Ascending then this else that
      for(s=0; s<SortRange; s++){
        for(t=0; t<SortRange-1; t++){
          if(  (this->ar[t])   < 
               (this->ar[t+1]) 
          ){
            iTemp=this->ar[t+1];
            this->ar[t+1]=this->ar[t];
            this->ar[t]=iTemp;
          };
        };
      };
    };
  };
  return bResult;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
bool JFC_AR::Flatten(void){
//----------------------------------------------------------------------------
  bool bResult=(this->Limit>0);
  if(bResult){
    int t; int s; int iTemp;
    if(this->Limit>1){ // Then sort Descending - kinda - Put ZERO's at end.
      for(s=0; s<Limit; s++){
        for(t=0; t<Limit-1; t++){
          if(  ((this->ar[t])   < (this->ar[t+1])) &&
               (this->ar[t]==0)
          ){
            iTemp=this->ar[t+1];
            this->ar[t+1]=this->ar[t];
            this->ar[t]=iTemp;
          };
        };
      };
    };
    int p_iNewSize=-1;
    while(this->ar[++p_iNewSize]!=0);
    this->Size_Set(p_iNewSize); 
  };
  return bResult;
};
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
bool JFC_AR::AppendItem(void){
//----------------------------------------------------------------------------
  bool bResult=this->Size_Set(this->Size+1);
  return bResult;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
bool JFC_AR::InsertItem(int p_Position){
//----------------------------------------------------------------------------
  bool bResult=(p_Position>-1) && (p_Position<this->Size);
  if(bResult){
    if(p_Position==(this->Size-1)){
      bResult=this->AppendItem();
    }else{
      bResult=this->Size_Set(this->Size+1); 
      if(bResult){
        int i=0;
        for(i=this->Size-1;i>p_Position;i--){
          ar[i]=ar[i-1];
        };
        ar[p_Position]=0;// New Position Starts off with a zero.  
      };
    };
  };  
  return bResult;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
bool JFC_AR::DeleteItem(int p_Position){//Slow
//----------------------------------------------------------------------------
  bool bResult=(p_Position>-1) && (p_Position<this->Size);
  if(bResult){
    int i=0;
    for(i=p_Position;i<this->Size-1;i++){
      ar[i]=ar[i+1];
    };
    bResult=this->Size_Set(this->Size-1);
  };
  return bResult;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
bool JFC_AR::DeleteAll(void){
//----------------------------------------------------------------------------
  bool bResult=(this->Limit_Set(0));
  return bResult;
};
//----------------------------------------------------------------------------


//============================================================================
// End                            JFC_AR
//=============================================================================