Homec4science
Diffusion Instrument Control (TekRSA-Freq-vs-Time) Browse

rINSTCONTROL/@MyMetadata/MyMetadata.m
57ed5bb3eb3eTekRSA-Freq-vs-Time

Last Change
Raw File

MyMetadata.m
View Options

classdef MyMetadata < dynamicprops
properties
uid;
hdr_spec;
end
properties (Access=private)
PropHandles; %Used to store the handles of the dynamic properties
end
properties (Dependent=true)
field_names;
end
methods
function [this,varargout]=MyMetadata(varargin)
p=inputParser;
addParameter(p,'uid',genUid())
addParameter(p,'hdr_spec','==',@ischar);
addParameter(p,'load_path','',@ischar);
addParameter(p,'end_header','Data',@ischar);
parse(p,varargin{:});
this.uid=p.Results.uid;
this.hdr_spec=p.Results.hdr_spec;
this.PropHandles=struct();
if ~isempty(p.Results.load_path)
varargout{1}=readHeaders(this,p.Results.load_path,...
'end_header',p.Results.end_header);
end
end
%Fields are added using this command. The field is a property of
%the class, populated by the parameters with their values and
%string specifications for later printing
function addField(this, field_name)
assert(ischar(field_name),'Field name must be a char');
this.PropHandles.(field_name)=addprop(this,field_name);
this.(field_name)=struct();
end
%Deletes a named field
function deleteField(this, field_name)
assert(ischar(field_name),'Field name must be a char')
assert(ismember(field_name,this.field_names),...
'Field name must be a valid property');
delete(this.PropHandles.(field_name));
this.PropHandles=rmfield(this.PropHandles,field_name);
end
%Clears the object of all fields
function clearFields(this)
cellfun(@(x) deleteField(this, x), this.field_names)
end
%This function adds a structure to a field of a given name. The
%field must be created before this can be used
function addStructToField(this, field_name, input_struct)
%Input checks
assert(ischar(field_name),'Field name must be a char');
assert(isprop(this,field_name),...
'%s is not a field, use addField to add it',field_name);
assert(isa(input_struct,'struct'),...
['The input_struct input must be a struct.',...
'Currently it is a %s'],class(input_struct))
%Adds the parameters specified in the input struct.
param_names=fieldnames(input_struct);
for i=1:length(param_names)
tmp=input_struct.(param_names{i});
addParam(this,field_name, ...
param_names{i},tmp.value,tmp.str_spec);
end
end
%Adds a parameter to a specified field. The field must be created
%first.
function addParam(this, field_name, name, value, str_spec)
assert(ischar(field_name),'Field name must be a char');
assert(isprop(this,field_name),...
'%s is not a field, use addField to add it',name);
assert(ischar(name),'Parameter name must be a char');
assert(ischar(str_spec),'String spec must be a char');
%Adds the field
this.(field_name).(name).value=value;
this.(field_name).(name).str_spec=str_spec;
end
function writeAllHeaders(this,fullfilename)
for i=1:length(this.field_names)
writeHeader(this, fullfilename, this.field_names{i});
end
end
function writeHeader(this, fullfilename, field_name, varargin)
%Takes optional inputs
p=inputParser;
addParameter(p,'title',field_name);
parse(p,varargin{:});
title_str=p.Results.title;
fileID=fopen(fullfilename,'a');
%Prints the header
fprintf(fileID,'%s%s%s\r\n',this.hdr_spec,title_str,this.hdr_spec);
ParamStruct=this.(field_name);
param_names=fieldnames(ParamStruct);
%plus one to padding for beauty
pad_length=max(cellfun(@(x) length(x), param_names))+1;
for i=1:length(param_names)
%Capitalize first letter of parameter name
fmt_name=[upper(param_names{i}(1)),param_names{i}(2:end)];
%Sets the string specifier for the parameter
if isfield(ParamStruct.(param_names{i}),'str_spec')
str_spec=ParamStruct.(param_names{i}).str_spec;
else
warning('No str_spec provided for %s, using char',param_names{i})
str_spec='%s';
end
print_spec=sprintf('%%-%ds\t%s\r\n',pad_length,str_spec);
fprintf(fileID,print_spec,fmt_name,...
ParamStruct.(param_names{i}).value);
end
%Prints an extra line at the end
fprintf(fileID,'\r\n');
fclose(fileID);
end
function n_end_header=readHeaders(this, fullfilename, varargin)
p=inputParser;
addParameter(p,'end_header','Data')
addParameter(p,'hdr_spec',this.hdr_spec);
parse(p,varargin{:});
end_header=p.Results.end_header;
this.hdr_spec=p.Results.hdr_spec;
%Before we load, we clear all fields
clearFields(this);
fileID=fopen(fullfilename);
title_exp=[this.hdr_spec,'(\w.*)',this.hdr_spec];
%Loop initialization
line_no=0;
curr_title='';
%Loop continues until we reach the next header or we reach the end of
%the file
while ~feof(fileID)
line_no=line_no+1;
%Grabs the current line
curr_line=fgetl(fileID);
%Gives an error if the file is empty, i.e. fgetl returns -1
if curr_line==-1; error('Tried to read empty file. Aborting.'); end
%Skips if current line is empty
if isempty(curr_line); continue; end
res_str=regexp(curr_line,title_exp,'once','tokens');
%If we find a title, first check if it is the specified end header.
%Then change the title if a title was found, then if no title was
%found, put the data under the current title.
if ~isempty(res_str) && contains(res_str,end_header)
break
elseif ~isempty(res_str)
curr_title=res_str{1};
%Capitalizes the letter after a space
ind=regexp([' ' curr_title],'(?<=\s+)\S','start')-1;
curr_title(ind)=upper(curr_title(ind));
%Removes spaces
curr_title=curr_title(~isspace(curr_title));
addField(this,curr_title);
%This runs if there was no match for the regular
%expression, i.e. the current line is not a header, and the
%current line is not empty. We then add this line to the
%current field (curr_title).
elseif ~isempty(curr_title)
tmp=strsplit(curr_line,'\t','CollapseDelimiters',true);
%Remove spaces
tmp=cellfun(@(x) erase(x,' '), tmp,'UniformOutput',false);
[val,str_spec]=str2doubleHedged(tmp{2});
%Store retrieved value
addParam(this,curr_title,tmp{1},val,str_spec);
end
end
if isempty(this.field_names)
warning('No header found, continuing without header')
n_end_header=1;
else
n_end_header=line_no;
end
end
end
methods
function field_names=get.field_names(this)
field_names=fieldnames(this.PropHandles);
end
end
end
c4science · Help