# Path: haystack/basicmodel.py
# def get_field_type(record, fieldname):
# def get_fields(record):
# def get_record_type_fields(record_type):
#     def __init__(self, memory_handler, my_constraints, target_ctypes=None):
#     def _get_constraints_for(self, record):
#     def _get_dynamic_constraints_for(self, record):
#     def get_orig_addr(self, record):
#     def is_valid(self, record):
#     def _is_valid_dynamic_constraints(self, record):
#     def _is_valid(self, record, record_constraints):
#     def _is_valid_attr(self, attr, attrname, attrtype, record_constraints):
#     def _is_loadable_member(self, attr, attrname, attrtype):
#     def load_members(self, record, max_depth):
#     def _load_member(self, record, attr, attrname, attrtype, record_constraints, max_depth):
#     def is_valid_address(self, obj, structType=None):
#     def is_valid_address_value(self, addr, structType=None):
#     def __str__(self):
# class CTypesRecordConstraintValidator(interfaces.IRecordConstraintsValidator):
#     MAX_CSTRING_SIZE = 1024
# 
# Path: haystack/constraints.py
# class ConstraintsConfigHandler(interfaces.IConstraintsConfigHandler):
# class ModuleConstraints(interfaces.IModuleConstraints):
# class RecordConstraints(interfaces.IRecordConstraints, dict):
# class IgnoreMember(interfaces.IConstraint):
# class ListLimitDepthValidation(interfaces.IConstraint):
# class RangeValue(interfaces.IConstraint):
# class NotValue(interfaces.IConstraint):
# class NotNullComparable(interfaces.IConstraint):
# class BytesComparable(interfaces.IConstraint):
#     def read(self, filename):
#     def _parse(self, value):
#     def _parse_c(self, value):
#     def _try_numbers(self, _arg):
#     def __init__(self):
#     def get_constraints(self):
#     def set_constraints(self, record_type_name, record_constraints):
#     def get_dynamic_constraints(self):
#     def set_dynamic_constraints(self, record_type_name, record_constraints):
#     def get_fields(self):
#     def get_constraints_for_field(self, field_name):
#     def __contains__(self, obj):
#     def __init__(self, max_depth):
#     def __contains__(self, obj):
#     def __init__(self, low, high):
#     def __contains__(self, obj):
#     def __eq__(self, obj):
#     def __init__(self, not_value):
#     def __contains__(self, obj):
#     def __eq__(self, obj):
#     def __contains__(self, obj):
#     def __eq__(self, obj):
#     def __init__(self, seq):
#     def __contains__(self, obj):
#     def __cmp__(self, obj):


import ctypes
import logging
            import traceback
from haystack import basicmodel
from haystack import constraints
        return self._double_link_list_types[record_type]

    def register_single_linked_list_record_type(self, record_type, forward, sentinels=None):
        """
        Declares a structure to be a single linked list management structure.

        register_single_linked_list_record_type(struct_SListEntry, 'forward')

        C code example:
            struct SListEntry {
                struct SListEntry * next;
            }

        Impacts:
        The effect will be the structure type's instance will NOT be validated, or loaded
        by the ListModel Constraints validator.
        No member, pointers members will be loaded.
        But elements of the list can be iterated upon with ListModel._iterate_double_linked_list,
        At what point, address validation of both forward and backward pointer
        occurs before loading of pointee elements.

        :param record_type: the ctypes.Structure type that holds double linked list pointers fields
        :param forward: the list pointer fieldname
        :return: None
        """
        if not issubclass(record_type, ctypes.Structure) and not issubclass(record_type, ctypes.Union):
            raise TypeError('Feed me a ctypes record rype')
        # test field existences in instance
        flink_type = getattr(record_type, forward)
        # test field existences in type

# Path: haystack/basicmodel.py
# def get_field_type(record, fieldname):
# def get_fields(record):
# def get_record_type_fields(record_type):
#     def __init__(self, memory_handler, my_constraints, target_ctypes=None):
#     def _get_constraints_for(self, record):
#     def _get_dynamic_constraints_for(self, record):
#     def get_orig_addr(self, record):
#     def is_valid(self, record):
#     def _is_valid_dynamic_constraints(self, record):
#     def _is_valid(self, record, record_constraints):
#     def _is_valid_attr(self, attr, attrname, attrtype, record_constraints):
#     def _is_loadable_member(self, attr, attrname, attrtype):
#     def load_members(self, record, max_depth):
#     def _load_member(self, record, attr, attrname, attrtype, record_constraints, max_depth):
#     def is_valid_address(self, obj, structType=None):
#     def is_valid_address_value(self, addr, structType=None):
#     def __str__(self):
# class CTypesRecordConstraintValidator(interfaces.IRecordConstraintsValidator):
#     MAX_CSTRING_SIZE = 1024
# 
# Path: haystack/constraints.py
# class ConstraintsConfigHandler(interfaces.IConstraintsConfigHandler):
# class ModuleConstraints(interfaces.IModuleConstraints):
# class RecordConstraints(interfaces.IRecordConstraints, dict):
# class IgnoreMember(interfaces.IConstraint):
# class ListLimitDepthValidation(interfaces.IConstraint):
# class RangeValue(interfaces.IConstraint):
# class NotValue(interfaces.IConstraint):
# class NotNullComparable(interfaces.IConstraint):
# class BytesComparable(interfaces.IConstraint):
#     def read(self, filename):
#     def _parse(self, value):
#     def _parse_c(self, value):
#     def _try_numbers(self, _arg):
#     def __init__(self):
#     def get_constraints(self):
#     def set_constraints(self, record_type_name, record_constraints):
#     def get_dynamic_constraints(self):
#     def set_dynamic_constraints(self, record_type_name, record_constraints):
#     def get_fields(self):
#     def get_constraints_for_field(self, field_name):
#     def __contains__(self, obj):
#     def __init__(self, max_depth):
#     def __contains__(self, obj):
#     def __init__(self, low, high):
#     def __contains__(self, obj):
#     def __eq__(self, obj):
#     def __init__(self, not_value):
#     def __contains__(self, obj):
#     def __eq__(self, obj):
#     def __contains__(self, obj):
#     def __eq__(self, obj):
#     def __init__(self, seq):
#     def __contains__(self, obj):
#     def __cmp__(self, obj):


# Path: haystack/listmodel.py
import ctypes
import logging
            import traceback
from haystack import basicmodel
from haystack import constraints

        return self._double_link_list_types[record_type]

    def register_single_linked_list_record_type(self, record_type, forward, sentinels=None):
        """
        Declares a structure to be a single linked list management structure.

        register_single_linked_list_record_type(struct_SListEntry, 'forward')

        C code example:
            struct SListEntry {
                struct SListEntry * next;
            }

        Impacts:
        The effect will be the structure type's instance will NOT be validated, or loaded
        by the ListModel Constraints validator.
        No member, pointers members will be loaded.
        But elements of the list can be iterated upon with ListModel._iterate_double_linked_list,
        At what point, address validation of both forward and backward pointer
        occurs before loading of pointee elements.

        :param record_type: the ctypes.Structure type that holds double linked list pointers fields
        :param forward: the list pointer fieldname
        :return: None
        """
        if not issubclass(record_type, ctypes.Structure) and not issubclass(record_type, ctypes.Union):
            raise TypeError('Feed me a ctypes record rype')
        # test field existences in instance
        flink_type = getattr(record_type, forward)
        # test field existences in type

        d = dict(basicmodel.get_record_type_fields(record_type))