Notes for Meeting

class Act_start : public Editor {
public:
    Act_start(VarPtr varInfo):Editor(varInfo) {}

    void edit() {

		// We need to justify the string because to_string() would otherwise return
		// just "0" when clockst was 0.
		long clockst_long =CLOCKST() == MISSING ? 0 : CLOCKST();
		
		string clockst = to_string(clockst_long);

		clockst = rightJustify(clockst,4,'0');

		const string hours = clockst.substr(0,2);
		const string minutes = clockst.substr(2,2);
		const string  act_start = hours + ":" + minutes + ":" + "00";
		setData(act_start);
	}

};

class F_clockstop : public Editor {
public:
    F_clockstop(VarPtr varInfo):Editor(varInfo) {}

    void edit() {
        int value = getEdited();
        /// The editing rule will assign to clockstop the start time of the next episode
        /// For the last episode, historical samples will have 12am and ATUS samples 4am
  	   // Use 2800 hour scale:
 	   long final_f_clockstop = datasetYear() < 2003 ? 2400 : 400;

        vector<ActivityRecordPtr> activityRecords = person()->activities();

		// Ensure we go through the activities in order:
        for (int rec=0;rec< activityRecords.size();rec++){
			ActivityRecordPtr activityRecord = activityRecords.at(rec);

			// Last activity record?
			if(rec == activityRecords.size() -1){
				setData(activityRecord, final_f_clockstop);
			}else{
				ActivityRecordPtr nextActivityRecord = activityRecords.at(rec+1);
				long clockst = CLOCKST(nextActivityRecord);
				setData(activityRecord, clockst);
			}
		}       
    }
};

#pragma once
#include <functional>
#include <algorithm>
#include <memory>
#include "Relate.h"
#include "Sex.h"



class Momloc:public Editor {
public:
    Momloc(VarPtr varInfo):Editor(varInfo) {}

    void edit() {
        setData(createWithImplicitLoop());

    }

    // Return MOMLOC value for current person only
    int createWithImplicitLoop() {
        int momloc = 0; // People are numbered 1-n
        switch(RELATE()) {
        case Relate::HEAD:
            momloc=findForHead();
            break;
            //case Relate::SPOUSE:momloc = findForSpouse();break;
        case Relate::CHILD:
        case Relate::CHILD_OF_HEAD:
            momloc = findForChild();
            break;
        case Relate::CHILD_OF_PARTNER:
            momloc = findForChildOfPartner();
            break;
            //case Relate::GRANDCHILD:momloc = findForGrandchild();break;

        }
        return momloc;
    }

    int findForHead() {

        // Look for PARENT who is female

        return pernumMatching([&](const RecordPtr person) {
            return Relate::PARENT == RELATE(person) && Sex::FEMALE == SEX(person);
        });

    }

// a CHILD is the child of the head so the mom is either the
// female householder or the spouse of the householder or the unmarried partner,
// but there is a separate child code for that
    int findForChild() {
        return pernumMatching([&](RecordPtr record) {
            return SEX(record) == Sex::FEMALE && (Relate::HEAD == RELATE(record)  || Relate::SPOUSE == RELATE(record));
        });
    }

    int findForChildOfPartner() {
        int mom = 0;
        // A different way to do something similar to findForChild():
        for(RecordPtr person:people()) {
            if (Relate::UNMARRIED_PARTNER == RELATE(person) &&
                    Sex::FEMALE == SEX(person)) {
                mom = PERNUM(person);
                break;
            }
        }
        return mom;
    }

    int pernumMatching(RecordMatches func) {
        RecordPtr person = findPersonMatching(func);
        if (person == nullptr) return 0;
        else return PERNUM(person);
    }

};

#include <functional>
#include <algorithm>
#include <memory>
#include "Relate.h"
#include "Sex.h"



class Poploc:public Editor {
#include "../helpers/FamilyRelationship.h"

public:

    Poploc(VarPtr varInfo):Editor(varInfo) {}
    void edit() {
        // Examine each person in combination with the current person.
        // First possible match wins.
		for(RecordPtr potentialFather:people()) {
            if (possibleFather(potentialFather)) {
                setData(PERNUM(potentialFather));
                break;
            }
        }
    }

    bool possibleFather(RecordPtr parent) {
        int age_diff =  AGE(parent) - AGE();

        return (age_diff > 17 &&
                SEX(parent) == Sex::MALE  &&
                validFatherRelationship(RELATE(parent),RELATE()));
    }

    bool validFatherRelationship(int adult, int child) {
        // This is a list (vector) of pairs
        vector<pair<int,int>> relate_pairs = {
            //{Relate::HEAD, Relate::CHILD},
            //{Relate::HEAD,Relate::CHILD_OF_HEAD},
            //{Relate::UNMARRIED_PARTNER,Relate::CHILD_OF_HEAD},
            //{Relate::PARENT,Relate::HEAD},
            //{Relate::CHILD,Relate::GRANDCHILD}
        };

        return  relationshipPairMatches(adult, child, relate_pairs);
    }

};