Resolve/C++ Catalog
CT/Partial_Map/Kernel_1_Part.h
Copyright © 2010, Reusable Software Research Group, The Ohio State University

//  /*-------------------------------------------------------------------*\
//  |   Concrete Template : Partial_Map_Kernel_1
//  \*-------------------------------------------------------------------*/

#ifndef CT_PARTIAL_MAP_KERNEL_1
#define CT_PARTIAL_MAP_KERNEL_1 1

///---------------------------------------------------------------------
/// Global Context -----------------------------------------------------
///---------------------------------------------------------------------

#include "AT/Partial_Map/Kernel.h"
/*!
    #include "AT/General/Is_Equal_To.h"
!*/
#include "CT/Queue/Kernel_1a.h"

///---------------------------------------------------------------------
/// Interface ----------------------------------------------------------
///---------------------------------------------------------------------

concrete_template <
	concrete_instance class D_Item,
	/*!
	    implements
		abstract_instance General_Is_Equal_To <D_Item, D_Item>
	!*/
	concrete_instance class R_Item,
        concrete_instance class D_R_Pair =
            Record <
		    D_Item, 
		    R_Item
                >,
        concrete_instance class Queue_Of_D_R_Pair =
            Queue_Kernel_1a <D_R_Pair>,
	concrete_instance class Rep =
            Representation <Queue_Of_D_R_Pair>
    >
class Partial_Map_Kernel_1 :
    implements
	abstract_instance Partial_Map_Kernel <D_Item, R_Item>,
    encapsulates
	concrete_instance Rep
{
private:

    rep_field_name (Rep, 0, Queue_Of_D_R_Pair, pairs_queue);

    field_name (D_R_Pair, 0, D_Item, d_item);
    field_name (D_R_Pair, 1, R_Item, r_item);
    
    /*!
	convention
	    for all d1, d2: D_Item, r1, r2: R_Item,
		a, b, c: string of (D_Item, R_Item)
		    where (self.pairs_queue =
			       a * <(d1,r1)> * b * <(d2,r2)> * c)
		(d1 /= d2)
		
	correspondence
	    self = elements (self.pairs_queue)
    !*/

    local_procedure_body Move_To_Front (
	    alters Queue_Of_D_R_Pair& q,
	    preserves D_Item& d
	)
    /*!
	ensures
	    q is permutation of #q  and
	    (if IS_DEFINED_IN (elements (q), d)
	     then there exists r: R_Item (<(d,r)> is prefix of q)
    !*/
    {
	object Integer pairs_left_to_check = q.Length ();

	while (pairs_left_to_check > 0)
	/*!
	    alters q, pairs_left_to_check
	    maintains
		q is permutation of #q  and
		there exists a, b: string of (D_Item, R_Item)
		    (q = a * b  and
		     |a| = pairs_left_to_check  and
		     not IS_DEFINED_IN (elements (b), d))
	    decreases
	        pairs_left_to_check
	!*/
	{
	    if (d.Is_Equal_To (q[current][d_item]))
	    {
		return;
	    }
	    else
	    {
		object catalyst D_R_Pair temp;

		q.Dequeue (temp);
		q.Enqueue (temp);
		pairs_left_to_check--;
	    }
	}
    }

public:

    standard_concrete_operations (Partial_Map_Kernel_1);

    procedure_body Define (
	    consumes D_Item& d,
            consumes R_Item& r
	)
    {
	object catalyst D_R_Pair temp;

	temp[d_item] &= d;
	temp[r_item] &= r;
	self[pairs_queue].Enqueue (temp);
    }

    procedure_body Undefine (
            preserves D_Item& d,
	    produces D_Item& d_copy,
            produces R_Item& r
	)
    {
	//-------- for students to fill in --------
    }

    procedure_body Undefine_Any (
	    produces D_Item& d,
	    produces R_Item& r
	)
    {
	//-------- for students to fill in --------
    }

    function_body Boolean Is_Defined (
	    preserves D_Item& d
	)
    {
	if (self[pairs_queue].Length () == 0)
	{
	    return false;
	}
	else
	{
	    Move_To_Front (self[pairs_queue], d);
	    return (d.Is_Equal_To (self[pairs_queue][current][d_item]));
	}
    }

    function_body R_Item& operator [] (
	    preserves D_Item& d
	)
    {
	Move_To_Front (self[pairs_queue], d);
	return self[pairs_queue][current][r_item];
    }

    function_body Integer Size ()
    {
	return self[pairs_queue].Length ();
    }

};

#endif // CT_PARTIAL_MAP_KERNEL_1