All Superinterfaces:: org.opendaylight.yangtools.yang.binding.DataRoot

public interface PathComputationData
extends org.opendaylight.yangtools.yang.binding.DataRoot

This module contains the model of Computed Path used in various Path algorithms. Copyright (c)2020 Orange. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html

This class represents the following YANG schema fragment defined in module path-computation

 module path-computation {
   yang-version 1;
   namespace urn:opendaylight:params:xml:ns:yang:path:computation;
   prefix algo;
   import network-concepts {
     prefix netc;
     revision-date 2013-11-25;
   }
   import ietf-inet-types {
     prefix inet;
     revision-date 2013-07-15;
   }
   import graph {
     prefix gr;
     revision-date 2019-11-25;
   }
   revision 2020-01-20 {
   }
   typedef computation-status {
     type enumeration {
       enum idle {
         value 0;
       }
       enum in-progress {
         value 1;
       }
       enum active {
         value 2;
       }
       enum completed {
         value 3;
       }
       enum failed {
         value 4;
       }
     }
   }
   typedef algorithm-type {
     type enumeration {
       enum spf {
         value 0;
       }
       enum cspf {
         value 1;
       }
       enum samcra {
         value 2;
       }
     }
     default spf;
   }
   grouping path-constraints {
     leaf metric {
       type uint32;
     }
     leaf te-metric {
       type uint32;
     }
     leaf delay {
       type gr:delay;
     }
     leaf jitter {
       type gr:delay;
     }
     leaf loss {
       type gr:loss;
     }
     leaf admin-group {
       type uint32;
     }
     leaf address-family {
       type enumeration {
         enum ipv4 {
           value 0;
         }
         enum ipv6 {
           value 1;
         }
         enum sr-ipv4 {
           value 2;
         }
         enum sr-ipv6 {
           value 3;
         }
       }
       default ipv4;
     }
     leaf class-type {
       type uint8 {
         range 0..7;
       }
     }
     leaf bandwidth {
       type gr:decimal-bandwidth;
     }
   }
   grouping sr-description {
     leaf sid {
       when "path-constraints/address-family = 2 or path-constraints/address-family = 3";
       type uint32;
     }
     leaf local-ipv4 {
       when "path-constraints/address-family = 2";
       type inet:ipv4-address;
     }
     leaf remote-ipv4 {
       when "path-constraints/address-family = 2";
       type inet:ipv4-address;
     }
     leaf local-ipv6 {
       when "path-constraints/address-family = 3";
       type inet:ipv6-address;
     }
     leaf remote-ipv6 {
       when "path-constraints/address-family = 3";
       type inet:ipv6-address;
     }
   }
   grouping path-descriptions {
     list path-description {
       leaf ipv4 {
         when "path-constraints/address-family = 0";
         type inet:ipv4-address;
       }
       leaf ipv6 {
         when "path-constraints/address-family = 1";
         type inet:ipv6-address;
       }
       uses sr-description;
     }
   }
   container constrained-path {
     uses path-constraints;
     leaf source {
       type uint64;
     }
     leaf destination {
       type uint64;
     }
     uses path-descriptions;
     leaf status {
       type computation-status;
     }
   }
   rpc get-constrained-path {
     input input {
       leaf graph-name {
         type string;
       }
       leaf source {
         type uint64;
       }
       leaf destination {
         type uint64;
       }
       container constraints {
         uses path-constraints;
       }
       leaf algorithm {
         type algorithm-type;
       }
     }
     output output {
       uses path-descriptions;
       leaf status {
         type computation-status;
       }
       leaf computed-metric {
         type uint32;
       }
       leaf computed-te-metric {
         type uint32;
       }
       leaf computed-delay {
         type gr:delay;
       }
     }
   }
 }

- Method Summary
  
  All Methods Instance Methods Abstract Methods
  Modifier and Type Method Description
  
  @Nullable ConstrainedPath getConstrainedPath()
  Computed Path as result of Path Computation Algorithms

- Method Detail
  - getConstrainedPath
```
@Nullable ConstrainedPath getConstrainedPath()
```
    Computed Path as result of Path Computation Algorithms
    
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.path.computation.rev200120.ConstrainedPath constrainedPath, or null if not present

Interface PathComputationData

Method Summary

Method Detail

getConstrainedPath