Skip to content

Server APIs – Aras.Server.Core.Configurator

Jump to bottom
Eric Domke edited this page Apr 6, 2020 · 1 revision

Aras.Server.Core v12.0.0.17204

Constant<T> Class

Inheritance object → Constant

public class Constant<T>
{
  // Constructors
  public Constant();
  public Constant(T value);

  // Properties
  public T Value { get; set; }
  public Type ValueType { get; }
}

DataType Enum

Inheritance object → ValueType → Enum → DataType

public enum DataType
{
  String = 0,
  Int = 1,
  DateTime = 2,
}

Enum Class

Inheritance object → Enum

public class Enum
{
  // Constructors
  public Enum(DataType? dataType);

  // Properties
  public DataType? DataType { get; }
  public string Id { get; set; }
  public string Name { get; set; }
  public IEnumerable<INamedConstant> NamedConstantList { get; }

  // Methods
  public Enum AddNamedConstant(INamedConstant namedConstant);
  public Enum AddNamedConstant(string id, string name, T value);
  public INamedConstant FindNamedConstantById(string namedConstantId);
}

ExpressionBase Class

Inheritance object → ExpressionBase

Derived ExpressionLogical, ExpressionTerm

public abstract class ExpressionBase
{

  // Properties
  public ExpressionType ExpressionType { get; }
  public ObservableList<ExpressionBase> InnerExpressions { get; }
}

ExpressionCombinator Class

Inheritance object → ExpressionCombinator

Attributes Extension


[Extension()]
public static class ExpressionCombinator
{

  // Methods
  [Extension()]
  public static IEnumerable<IEnumerable<T>> GetCombinations(IEnumerable<IEnumerable<T>> sequences);
}

ExpressionConverter Class

Inheritance object → ExpressionConverter

public class ExpressionConverter
{
  // Constructors
  public ExpressionConverter();

  // Properties
  public static ExpressionConverter Instance { get; }

  // Methods
  public ExpressionBase FromXml(XmlNode expressionNode);
  public XmlElement ToXml(ExpressionBase expression);
}

ExpressionLogical Class

Inheritance object → ExpressionBase → ExpressionLogical

public class ExpressionLogical : ExpressionBase
{
  // Constructors
  public ExpressionLogical(ExpressionType expressionType);

  // Properties
  public List<ExpressionTerm> InnerTerms { get; }
}

ExpressionSortComparer Class

Inheritance object → ExpressionSortComparer

Implements IComparer<ExpressionBase>

public class ExpressionSortComparer : IComparer<ExpressionBase>
{
  // Constructors
  public ExpressionSortComparer();

  // Methods
  public int Compare(ExpressionBase x, ExpressionBase y);
}

ExpressionTerm Class

Inheritance object → ExpressionBase → ExpressionTerm

Implements IEquatable<ExpressionTerm>, ITerm

public class ExpressionTerm : ExpressionBase, IEquatable<ExpressionTerm>, ITerm
{
  // Constructors
  public ExpressionTerm(TermOperator operator, ITermOperand operandLeft, ITermOperand operandRight);

  // Properties
  public ExpressionType ExpressionType { get; }
  public ITermOperand OperandLeft { get; }
  public ITermOperand OperandRight { get; }
  public TermOperator Operator { get; }

  // Methods
  public bool Equals(object obj);
  public bool Equals(ExpressionTerm other);
  public int GetHashCode();
}

ExpressionTermFlyweightFactory Class

Inheritance object → TermFlyweightFactory → ExpressionTermFlyweightFactory

Implements IExpressionTermFlyweightFactory

public class ExpressionTermFlyweightFactory : TermFlyweightFactory, IExpressionTermFlyweightFactory
{

  // Properties
  public static IExpressionTermFlyweightFactory Instance { get; }

  // Methods
  public ExpressionTerm GetExpressionTerm(TermOperator termOperator, ITermOperand operandLeft, ITermOperand operandRight);
}

ExpressionToStringNotationConverter Class

Inheritance object → ExpressionToStringNotationConverter

Implements IStringNotationConverter

public class ExpressionToStringNotationConverter : IStringNotationConverter
{
  // Constructors
  public ExpressionToStringNotationConverter(IEnumerable<Variable> variablesContainer);

  // Methods
  public string ConvertExpressionToStringNotation(ExpressionBase expression);
}

ExpressionType Enum

Inheritance object → ValueType → Enum → ExpressionType

public enum ExpressionType
{
  AND = 0,
  OR = 1,
  NOT = 2,
  IMPLICATION = 3,
  Term = 4,
  ExactlyOne = 5,
  AtLeastOne = 6,
  AtMostOne = 7,
}

ExpressionTypeParse Class

Inheritance object → ExpressionTypeParse

public static class ExpressionTypeParse
{

  // Methods
  public static bool TryParseNodeToExpressionType(string nodeName, bool ignoreCase, out ExpressionType expressionType);
}

GetScopeStructureOutputBase Class

Inheritance object → GetScopeStructureOutputBase

public class GetScopeStructureOutputBase
{
  // Constructors
  public GetScopeStructureOutputBase(IServerConnection iomConnection);

  // Properties
  public IServerConnection IomConnection { get; }

  // Methods
  public void ExtendNamedConstant(Item namedConstantItem);
  public void ExtendRule(Item ruleItem);
  public void ExtendScope(Item scopeItem);
  public void ExtendVariable(Item variableItem);
  public void Init(XmlElement requestItem, Scope scope);
}

IExpressionTermFlyweightFactory Interface

Implements ITermFlyweightFactory

public interface IExpressionTermFlyweightFactory : ITermFlyweightFactory
{

  // Methods
  public ExpressionTerm GetExpressionTerm(TermOperator termOperator, ITermOperand operandLeft, ITermOperand operandRight);
}

INamedConstant Interface

public interface INamedConstant
{

  // Properties
  public string Id { get; set; }
  public string Name { get; set; }
  public Type ValueType { get; }

  // Methods
  public object GetValue();
  public void SetValue(object value);
}

IStringNotationConverter Interface

public interface IStringNotationConverter
{

  // Methods
  public string ConvertExpressionToStringNotation(ExpressionBase expression);
}

ITerm Interface

public interface ITerm
{

  // Properties
  public ITermOperand OperandLeft { get; }
  public ITermOperand OperandRight { get; }
  public TermOperator Operator { get; }
}

ITermFlyweightFactory Interface

public interface ITermFlyweightFactory
{

  // Properties
  public int Count { get; }
  public IEnumerable<ITerm> TermEntities { get; }

  // Methods
  public void Clear();
  public ITerm GetTerm(TermOperator termOperator, ITermOperand operandLeft, ITermOperand operandRight);
  public bool RemoveTerm(ITerm term);
  public bool RemoveTerm(TermOperator termOperator, ITermOperand operandLeft, ITermOperand operandRight);
}

ITermOperand Interface

Implements IEquatable<ITermOperand>

public interface ITermOperand : IEquatable<ITermOperand>
{

  // Properties
  public TermOperandType OperandType { get; }

  // Methods
  public string GetId();
  public object GetValue();
}

NamedConstant<T> Class

Inheritance object → Constant<T> → NamedConstant

Implements INamedConstant

public class NamedConstant<T> : Constant<T>, INamedConstant
{
  // Constructors
  public NamedConstant(string id, string name);

  // Properties
  public string Id { get; set; }
  public string Name { get; set; }

  // Methods
  public object GetValue();
  public void SetValue(object value);
}

ObservableList<T> Class

Inheritance object → List<T> → ObservableList

Implements INotifyCollectionChanged


public class ObservableList<T> : List<T>, INotifyCollectionChanged
{
  // Constructors
  public ObservableList();
  public ObservableList(int capacity);
  public ObservableList(IEnumerable<T> collection);

  // Properties
  public T this[int index] { get; set; }

  // Methods
  public void Add(T item);
  public void AddRange(IEnumerable<T> collection);
  public void Clear();
  public void Insert(int index, T item);
  public void InsertRange(int index, IEnumerable<T> collection);
  public bool Remove(T item);
  public int RemoveAll(Predicate<T> match);
  public void RemoveAt(int index);
  public void RemoveRange(int index, int count);
}

Rule Class

Inheritance object → Rule

public class Rule
{
  // Constructors
  public Rule();

  // Properties
  public ExpressionBase Definition { get; set; }
  public string Id { get; set; }
  public string Name { get; set; }
}

Scope Class

Inheritance object → Scope

public class Scope
{
  // Constructors
  public Scope();

  // Properties
  public string Id { get; set; }
  public string Name { get; set; }
  public IList<Rule> RuleList { get; }
  public IList<Variable> VariableList { get; }
}

ScopeBuilderBase Class

Inheritance object → ScopeBuilderBase

public abstract class ScopeBuilderBase
{

  // Properties
  public IServerConnection IomConnection { get; }
  public Item ScopeItem { get; set; }

  // Methods
  public abstract Scope BuildScope();
  public abstract ArrayList GetCustomKey();
  public abstract string[] GetGuidsItemDependsOn();
  public abstract List<string> GetItemTypeNamesItemDependsOn();
  public void Init(Item scopeItem, IServerConnection iomConnection);
}

TermFlyweightFactory Class

Inheritance object → TermFlyweightFactory

Derived ExpressionTermFlyweightFactory

Implements ITermFlyweightFactory

public class TermFlyweightFactory : ITermFlyweightFactory
{

  // Properties
  public int Count { get; }
  public IEnumerable<ITerm> TermEntities { get; }

  // Methods
  public void Clear();
  public ITerm GetTerm(TermOperator termOperator, ITermOperand operandLeft, ITermOperand operandRight);
  public bool RemoveTerm(ITerm term);
  public bool RemoveTerm(TermOperator termOperator, ITermOperand operandLeft, ITermOperand operandRight);
}

TermOperandConstant<T> Class

Inheritance object → TermOperandConstant

Implements ITermOperand

public class TermOperandConstant<T> : ITermOperand
{
  // Constructors
  public TermOperandConstant(Constant<T> constant);

  // Properties
  public TermOperandType OperandType { get; }

  // Methods
  public bool Equals(ITermOperand other);
  public int GetHashCode();
  public string GetId();
  public object GetValue();
}

TermOperandNamedConstant Class

Inheritance object → TermOperandNamedConstant

Implements ITermOperand

public class TermOperandNamedConstant : ITermOperand
{
  // Constructors
  public TermOperandNamedConstant(string namedConstantId);

  // Properties
  public TermOperandType OperandType { get; }

  // Methods
  public bool Equals(ITermOperand other);
  public int GetHashCode();
  public string GetId();
  public object GetValue();
}

TermOperandType Enum

Inheritance object → ValueType → Enum → TermOperandType

Attributes Flags


[Flags()]
public enum TermOperandType
{
  Constant = 1,
  NamedConstant = 2,
  Variable = 4,
}

TermOperandVariable Class

Inheritance object → TermOperandVariable

Implements ITermOperand

public class TermOperandVariable : ITermOperand
{
  // Constructors
  public TermOperandVariable(string variableId);

  // Properties
  public TermOperandType OperandType { get; }

  // Methods
  public bool Equals(ITermOperand other);
  public int GetHashCode();
  public string GetId();
  public object GetValue();
}

TermOperator Enum

Inheritance object → ValueType → Enum → TermOperator

Attributes Flags


[Flags()]
public enum TermOperator
{
  Equal = 1,
  GreaterThanOrEqual = 2,
  LessThanOrEqual = 4,
}

Variable Class

Inheritance object → Variable

public class Variable
{
  // Constructors
  public Variable(DataType? dataType);

  // Properties
  public DataType? DataType { get; }
  public Enum Enum { get; set; }
  public string Id { get; set; }
  public string Name { get; set; }
}

Home

Clone this wiki locally