HK_Batches.cpp

Go to the documentation of this file.

/*******************************************************************/
#include "../headers/Batches.h"
 
HK_Batches::HK_Batches(){}
 
void HK_Batches::Add(HK_Batch Batch){
    HK_BatchInstance.push_back(Batch);
    HK_BatchDirty.push_back(false);
}
 
void HK_Batches::Add(int ID, string Name, string Type,
    string Breed, string Group, string Comments, string Incubator,
    int Eggs, int Fertile, int Chicks,
    HK_Date Start, HK_Date Candle, HK_Date Lockdown, HK_Date Hatch,
    int Remind, int Adv)
{
    //Push Empty Batch
    HK_Batch Batch;
    HK_BatchInstance.push_back(Batch);
    HK_BatchInstance[GetCount() - 1].Set( 
        ID, Name, Type, Breed, Group, Comments, Incubator,Eggs, 
        Fertile, Chicks, Start, Candle, Lockdown, Hatch, Remind, Adv
    );
    HK_BatchDirty.push_back(false);
}
 
bool HK_Batches::AddAdvanced(HK_Advanced Adv)
{
    int Select = -1;
    
    for(int A  = 0; A < GetCount(); A++)
        if(Adv.GetID() == GetID(A))
            Select = A;
    
    if(Select == -1)
        return false;
    else
        HK_BatchInstance[Select].SetAdvanced(Adv);
        
    return true;    
}
 
HK_Batch HK_Batches::GetBatch(int Select)
{
    return HK_BatchInstance[Select];
}
 
int HK_Batches::GetID(int Select){return HK_BatchInstance[Select].GetID();}
string HK_Batches::GetName(int Select){return HK_BatchInstance[Select].GetName();}
string HK_Batches::GetType(int Select){return HK_BatchInstance[Select].GetType();}
string HK_Batches::GetBreed(int Select){return HK_BatchInstance[Select].GetBreed();}
string HK_Batches::GetGroup(int Select){return HK_BatchInstance[Select].GetGroup() ;}
string HK_Batches::GetComments(int Select){return HK_BatchInstance[Select].GetComments();}
string HK_Batches::GetIncubator(int Select){return HK_BatchInstance[Select].GetIncubator();}
int HK_Batches::GetEggs(int Select){return HK_BatchInstance[Select].GetEggs();}
int HK_Batches::GetFertile(int Select){return HK_BatchInstance[Select].GetFertile();}
int HK_Batches::GetChicks(int Select){return HK_BatchInstance[Select].GetChicks();}
HK_Date HK_Batches::GetStart(int Select){return HK_BatchInstance[Select].GetStart();}
HK_Date HK_Batches::GetCandle(int Select){return HK_BatchInstance[Select].GetCandle();}
HK_Date HK_Batches::GetLockdown(int Select){return HK_BatchInstance[Select].GetLockdown();}
HK_Date HK_Batches::GetHatch(int Select){return HK_BatchInstance[Select].GetHatch();}
int HK_Batches::GetRemind(int Select){return HK_BatchInstance[Select].GetRemind();}
int HK_Batches::GetAdv(int Select){return HK_BatchInstance[Select].GetAdv();}
HK_Advanced HK_Batches::GetAdvanced(int Select){return HK_BatchInstance[Select].GetAdvanced();}
 
vector<string> HK_Batches::GetSQL(int Select, int ID)
{
    return HK_BatchInstance[Select].GetSQL(ID);
}
 
bool HK_Batches::IsDirty(int Select){return HK_BatchDirty[Select];}
 
int HK_Batches::PercentFertile(int Select)
{
    return HK_BatchInstance[Select].PercentFertile();
}
 
int HK_Batches::PercentOfFertile(int Select)
{
    return HK_BatchInstance[Select].PercentOfFertile();
}
 
int HK_Batches::PercentOfTotal(int Select)
{
    return HK_BatchInstance[Select].PercentOfTotal();
}
 
int HK_Batches::FertileUnhatched(int Select)
{
    return HK_BatchInstance[Select].FertileUnhatched();
}
 
int HK_Batches::PercentOfTotalUnhatched(int Select)
{
    return HK_BatchInstance[Select].PercentOfTotalUnhatched();
}
 
 
int HK_Batches::TotalEggs()
{
    int Total = 0;
    for(int A = 0; A < GetCount(); A++)
        Total += GetEggs(A);
    return Total;
}
 
int HK_Batches::TotalChicks()
{
    int Total = 0;
    for(int A = 0; A < GetCount(); A++)
        Total += GetChicks(A);
    return Total;
}
 
int HK_Batches::AvgFertile()
{
    int Total = 0;
    for(int A = 0; A < GetCount(); A++) 
        Total += PercentFertile(A);
    return Total / GetCount();
}
 
int HK_Batches::AvgTotalHatch()
{
    int Total = 0;
    for(int A = 0; A < GetCount(); A++)
        Total += PercentOfTotal(A);
    return Total / GetCount();
}
 
int HK_Batches::AvgFertileHatch()
{
    int Total = 0;
    for(int A = 0; A < GetCount(); A++)
        Total += PercentOfFertile(A);
    return Total / GetCount();
}
 
int HK_Batches::AvgTotalUnHatch()
{
    int Total = 0;
    for(int A = 0; A < GetCount(); A++)
        Total += PercentOfTotalUnhatched(A);
    return Total / GetCount();
}
 
 
int HK_Batches::GetCount(){return HK_BatchInstance.size();}
 
int HK_Batches::GetValidID()
{
    int A = 0, B, ID = -1;
    bool Found = false;
    while(ID == -1) {
        Found = false;
        for(B = 0;B < GetCount(); B++) {
            if( GetID(B) == A) {   
                Found = true;
                break;
            } 
        }
        if(!Found) {
            ID = A;
            break;
        }
        A++;
    }
    return A;
}
 
bool HK_Batches::IsValidName(string Name)
{
    for(int A = 0; A < GetCount(); A++)
        if(GetName(A) == Name)
            return false;
    
    return true;
}
 
void HK_Batches::Clear()
{
    HK_BatchInstance.clear();
    HK_BatchInstance.shrink_to_fit();
}
 
HK_KeyValue HK_Batches::Search(string Value, bool SearchBatch, bool SearchAdv)
{
    HK_KeyValue Results;
    
    for(int A = 0; A < GetCount(); A++) 
        Results.Add(HK_BatchInstance[A].Search(Value, SearchBatch, SearchAdv));
 
    return Results;
}
 
void HK_Batches::SetAdvEgg(int Select, HK_Egg Egg, int EggSelect)
{
    HK_BatchInstance[Select].SetAdvEgg(Egg,EggSelect);
    SetDirty(Select);
}
void HK_Batches::SetAdvUpdate(int Select, bool Status){HK_BatchInstance[Select].SetAdvUpdate(Status);}
 
void HK_Batches::SetBatch(int Select, HK_Batch Batch)
{
    HK_BatchInstance[Select] = Batch;
    SetDirty(Select);
}
void HK_Batches::SetClean(int Select){HK_BatchDirty[Select] = false;}
void HK_Batches::SetDirty(int Select){HK_BatchDirty[Select] = true;}