FILTER WHERE
Subject CONTAINS "Order Confirmation"
AND
Email FROM "billyjones26@gmail.com" OR "billyjones26@googlemail.com"

public function check_email(){
    $filters = $this->filters_model->get_filters($owner_id=1);
    foreach($filters->result() as $filter){
        $emails = $this->gmail->get_emails($mailbox_id = $filter->mailbox_id, $limit = 10);

        $matched = array();
        $conditions = unserialize($filter->conditions);

        foreach($emails as $email){
            if($conditions->isMet($email) == TRUE){
                $matched[] = $email;
            }
        }

        echo count($matched);
        echo '<pre>'.$filter->title.'<br /.';
        print_r($conditions);
        echo '</pre><br />-----';
        exit;
    }
}

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class Keyvalueprerequisite {

    private $key;
    private $comparator;
    private $value;

    public function __construct($key, $comparator, $value){
        $this->key = $key;
        $this->comparator = $comparator;
        $this->value = $value;
    }


    public function isMet(&$context)
    {
        switch ($this->key) {

            case "subject":

                $subject = $context["subject"];
                if ($this->comparator === "in"){
                    return stripos($subject, $this->value) !== FALSE;
                } else if ($this->comparator === "!in") {
                    return stripos($subject, $this->value) === FALSE;
                }

                return FALSE;

                break;

            case "body":

                $body = $context["body"];

                if ($this->comparator === "in") {
                    return stripos($body, $this->value) !== FALSE;
                } else if ($this->comparator === "!in") {
                    return stripos($body, $this->value) === FALSE;
                }

                return FALSE;

                break;

            case "from_address":

                $from = $context["from"];

                if ($this->comparator === "=") {
                    return $this->value === $from;
                } else if ($this->comparator === "!=") {
                    return $this->value !== $from;
                } else{
                    return false;
                }

                break;

            default:
        }

        return FALSE;
    }

}

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class Prerequisitegroup {

    private $type;
    private $prerequisites;

    public function __construct($type = 'AND'){
        $this->type = $type;
    }

    public function add(){
        foreach(func_get_args() as $prerequisite){
          $this->prerequisites[] = $prerequisite;
        }
    }

    public function isMet(&$context)
    {
        if (empty($this->prerequisites) === FALSE) {
            $result = TRUE;

            foreach ($this->prerequisites as $prerequisite) {
                $is_met = $prerequisite->isMet($context);
                if ($this->type === 'AND') {
                    $result = $result && $is_met;
                    if ($result === FALSE) {
                        return FALSE;
                    }
                } else {
                    $result = $result || $is_met;
                    if ($result === TRUE) {
                        return TRUE;
                    }
                }
            }
            return $result;
        }

        return TRUE;
    }


}

string(3) "AND"
  ["prerequisites":"Prerequisitegroup":private]=>
  array(1) {
    [0]=>
    object(Prerequisitegroup)#23 (2) {
      ["type":"Prerequisitegroup":private]=>
      string(2) "OR"
      ["prerequisites":"Prerequisitegroup":private]=>
      array(1) {
        [0]=>
        object(Keyvalueprerequisite)#24 (3) {
          ["key":"Keyvalueprerequisite":private]=>
          string(7) "subject"
          ["comparator":"Keyvalueprerequisite":private]=>
          string(2) "in"
          ["value":"Keyvalueprerequisite":private]=>
          string(4) "TEST"
        }
      }
    }
  }
}

$c1 = new KeyValuePrerequisite("EmailFrom", "=", "billyjones26@gmail.com");
$c2 = new KeyValuePrerequisite("EmailFrom", "=", "billyjones26@googlemail.com");
$c3 = new KeyValuePrerequisite("Subject", "in", "Order Confirmation");

$from_condition = new PrerequisiteGroup('or');
$from_condition->add($c1, $c2);

$final_condition = new PrerequisiteGroup($c3, $from_condition); // defaults to and

$db->query("INSERT INTO conditions SET user_id = %i, conditions = %l", $user_id, serialize($final_condition));

// Fetch conditions

$email_conditions = $user->getEmailConditions()

// Connect to your inbox and fetch relevant emails

$matching_emails = array();
foreach ($emails as $email) {
    if ($email_conditions->isMet($email) {
        $matching_emails[] = $email;
    }
}

interface Prerequisite
{
    /**
     * Must return TRUE or FALSE.
     */
    public function isMet(&$context);
}

class KeyValuePrerequisite extends PrerequisiteGroup
{
    protected $key;
    protected $comparator;
    protected $value;

    public function __construct($key, $comparator, $value = NULL)
    {
        $this->key        = $key;
        $this->comparator = $comparator;
        $this->value      = $value;
    }

    public function isMet(&$context)
    {
        switch ($this->key) {

            case "Subject":

                $subject = $context["subject"];

                if ($this->comparator === "in") }
                    return stripos($subject, $this->value) !== FALSE;
                } else if ($this->comparator === "not int") {
                    return stripos($subject, $this->value) === FALSE;
                }

                return FALSE;

                break;

            case "EmailFrom":

                $from = $context["from"];

                return $this->value === $from;

                break;

            default:
        }

        return FALSE;
    }
}

class PrerequisiteGroup implements Prerequisite
{
    private $type;
    private $prerequisites;

    public function __construct($type = 'AND')
    {
        $this->type = $type;
    }

    public function add(Prerequisite $prerequisite)
    {
        if ($prerequisite instanceof Prerequisite) {
            $this->prerequisites[] = $prerequisite;
        } else {
            throw new Exception('Unknown Prerequisite type ' . get_class($prerequisite));
        }
    }

    public function isMet(&$context)
    {
        if (empty($this->prerequisites) === FALSE) {
            $result = $this->type === 'AND';
            foreach ($this->prerequisites as $prerequisite) {
                $is_met = $prerequisite->isMet($context);
                if ($this->type === 'AND') {
                    $result = $result && $is_met;
                    if ($result === FALSE) {
                        return FALSE;
                    }
                } else {
                    $result = $result || $is_met;
                    if ($result === TRUE) {
                        return TRUE;
                    }
                }
            }
            return $result;
        }

        return TRUE;
    }
}

Row 1: [select: subject] [select:contains] [input:"Order Confirmation"]