ippPropDefinition.cpp

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 
//
#include "stdafx.h"
#include "ippdme/misc/ippPropDefinition.h"



ippPropDefinition::ippPropDefinition(
  ippOtherKeyType keyword,
  propType type
) 
  : _keyword(keyword) 
  , _properties(0)
  , _n_properties(0)
  , _type(type)
{ 
}

ippPropDefinition::ippPropDefinition(
 ippOtherKeyType keyword,
 const ippPropDefinition* prop,
 int n
)
  : _keyword(keyword) 
  , _properties(prop)
  , _n_properties(n)
  , _type(object)
{
}
  
const ippPropDefinition* ippPropDefinition::find(
  const ippProp& prop,
  bool bLeafOnly
)const
{
  const ippPropDefinition* retval = 0;
  if (_keyword!= prop.getKey1()) { 
    return retval;
  }
  if (prop.getKey2() == EmptyKey && !bLeafOnly) { 
     return this;
  }
  ippProp p(prop.getKey2(),prop.getKey3(),prop.getKey4());
  if (_n_properties) { 
    for (int i=0;i<_n_properties;i++) { 
      retval = _properties[i].find(p,bLeafOnly);
      if (retval) {
        return retval;
      }
    }
    return 0;
  } 
  return this;
}
#define _count(a) sizeof(a)/sizeof(a[0])

const ippPropDefinition paramDefinition[] = { 
  ippPropDefinition(EmptyKey,read_write),
  ippPropDefinition(Actual,read_write),
  ippPropDefinition(Default,read_only),
  ippPropDefinition(Max,read_only),
  ippPropDefinition(Min,read_only)
};

const ippPropDefinition paramSpeed   (Speed   ,paramDefinition,_count(paramDefinition));
const ippPropDefinition paramAccel   (Accel   ,paramDefinition,_count(paramDefinition));
const ippPropDefinition paramApproach(Approach,paramDefinition,_count(paramDefinition));
const ippPropDefinition paramRetract (Retract ,paramDefinition,_count(paramDefinition));
const ippPropDefinition paramSearch  (Search  ,paramDefinition,_count(paramDefinition));

const ippPropDefinition GotoParProp_[]= {paramSpeed, paramAccel};

const ippPropDefinition paramGotoPar(GoToPar, GotoParProp_,_count(GotoParProp_));

const ippPropDefinition paramPtMeasPar_[] = { paramSpeed, paramAccel , paramApproach, paramRetract , paramSearch};
const ippPropDefinition paramPtMeasPar(PtMeasPar,paramPtMeasPar_,_count(paramPtMeasPar_));

const ippPropDefinition paramScanPar_[] = { paramSpeed, paramAccel , paramRetract };
const ippPropDefinition paramScanPar(ScanPar,paramScanPar_,_count(paramScanPar_));

const ippPropDefinition paramTool_[] = { 
  ippPropDefinition(Alignment,complex_type),
  ippPropDefinition(AlignmentVolume,complex_type),
  ippPropDefinition(AvrRadius,read_only),
  ippPropDefinition(Name,complex_type),
  ippPropDefinition(CollisionVolume,complex_type),
  ippPropDefinition(Id,complex_type),
  ippPropDefinition(Collection,complex_type) ,
   paramGotoPar, paramPtMeasPar , paramScanPar };

const ippPropDefinition paramTool(Tool, paramTool_, _count(paramTool_));
const ippPropDefinition paramFoundTool(FoundTool, paramTool_, _count(paramTool_));

const ippPropDefinition paramPart_[] = { 
  ippPropDefinition(Temperature,read_write),
  ippPropDefinition(XPanCoefficient,read_write),
  // Part.Approach is mentioned / suggested in A.2.2 of ippdme 1.5
  paramApproach,
  // Part.Search is mentioned / suggested  in 6.3.2.13 of ippdme 1.5
  paramSearch

};
const ippPropDefinition paramPart(Part,paramPart_,_count(paramPart_));

const ippPropDefinition paramGetProp_[] = { paramPart,paramTool,paramFoundTool };


bool IsObjectOrProperty(const ippProp& prop)
{
  for (int i=0;i<_count(paramGetProp_) ; i++) { 
    const ippPropDefinition& def = paramGetProp_[i];

    ippProp prop1(prop.getKey1(),prop.getKey2(),prop.getKey3());

    if (def._keyword == prop.getKey1()) {
      
      const ippPropDefinition* found_prop = def.find(prop,false);

      if (found_prop )  {
        return true;
      }
     }
  }
  return false;
}
bool IsMainObject(const ippOtherKeyType keyword1,const ippOtherKeyType keyword2)
{
  return IsObjectOrProperty(ippProp(keyword1,keyword2));
}
bool PropertyIsDouble(const ippProp& prop) 
{
  for (int i=0;i<_count(paramGetProp_) ; i++) { 
    const ippPropDefinition& def = paramGetProp_[i];
    const ippPropDefinition* found_prop = def.find(prop);
    if (found_prop && ( found_prop->_type == read_only ||  found_prop->_type ==  read_write)) { 
      return true;
    }
  }
  return false;
}
bool PropertyIsAllowed(const ippProp& prop) 
{ 
  for (int i=0;i<_count(paramGetProp_) ; i++) { 
    const ippPropDefinition& def = paramGetProp_[i];
    const ippPropDefinition* found_prop = def.find(prop);
    if (found_prop) { 
      return true;
    }
  }
  return false;
}
bool PropertyIsAllowedAndWritable(const ippProp& prop) { 
  for (int i=0;i<_count(paramGetProp_) ; i++) { 
    const ippPropDefinition& def = paramGetProp_[i];
    const ippPropDefinition* found_prop = def.find(prop);
    if (found_prop && found_prop->_type == read_write) { 
      return true;
    }
  }
  return false;
}

const ippPropDefinition* findPropertyDefinition(const ippProp& prop)
{
  for (int i=0;i<_count(paramGetProp_) ; i++) { 
    const ippPropDefinition& def = paramGetProp_[i];

    const ippPropDefinition* p = def.find(prop,false);
    if (p) {
        return p;
    }
  }
  return 0; 
}

---