Getter method for instance variable {@link #childs}.
@return value of instance variable {@link #childs}
@throws CacheReloadException on error
426811
public Set<Classification> getChildClassifications()
        throws CacheReloadException
    {
        final Set<Classification> ret = new HashSet<>();
        for (final Long id : this.children) {
            final Classification child = Classification.get(id);
            ret.add(child);
        }
        return Collections.unmodifiableSet(ret);
    }
116546
public static function singleton()
    {
        $returnValue = null;

        
        $cacheName = get_called_class();
        if (!isset(self::$instances[$cacheName])) {
        	self::$instances[$cacheName] = new $cacheName();
        }
        
        $returnValue = self::$instances[$cacheName];
        

        return $returnValue;
    }
173274
@Override
    public int getIndexOfChild(Object parentObj, Object childObj) {
        if (debugger == null) {
            return -1;
        }
        VariableNode parent = (VariableNode) parentObj;
        VariableNode child = (VariableNode) childObj;
        VariableNode[] children = children(parent);
        for (int i = 0; i != children.length; i++) {
            if (children[i] == child) {
                return i;
            }
        }
        return -1;
    }
610340
@Override
    public Set<IGroupMember> getChildren() throws GroupsException {

        final EntityIdentifier cacheKey = getUnderlyingEntityIdentifier();
        Element element = childrenCache.get(cacheKey);

        if (element == null) {
            final Set<IGroupMember> children = buildChildrenSet();
            element = new Element(cacheKey, children);
            childrenCache.put(element);
        }

        @SuppressWarnings("unchecked")
        final Set<IGroupMember> rslt = (Set<IGroupMember>) element.getObjectValue();
        return rslt;
    }
922763
public List<String> getRootChildren() {

        List<String> children = new ArrayList<String>();
        try {
            children = zk.getChildren("/", false);
        } catch (KeeperException e) {
            LOGGER.error(e.toString());
        } catch (InterruptedException e) {
            LOGGER.error(e.toString());
        }

        return children;
    }
260704
public function getChildren()
    {
        if (isset($this->relations['children'])) {
            return $this->relations['children'];
        }

        $children = $this->getAttribute('children');

        return $children === null ? [] : $children;
    }
1109520
private static Set<Type> getChildTypes(final Type _type)
        throws CacheReloadException
    {
        final Set<Type> ret = new HashSet<Type>();
        ret.add(_type);
        for (final Type child : _type.getChildTypes()) {
            ret.addAll(getChildTypes(child));
        }
        return ret;
    }
491643
public static Role get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, Role> cache = InfinispanCache.get().<String, Role>getCache(Role.NAMECACHE);
        if (!cache.containsKey(_name) && !Role.getRoleFromDB(Role.SQL_NAME, _name)) {
            cache.put(_name, Role.NULL, 100, TimeUnit.SECONDS);
        }
        final Role ret = cache.get(_name);
        return ret.equals(Role.NULL) ? null : ret;
    }
376444
protected Object getFromCache(String cacheName, String key) {
        try {
            ICache cache = getCache(cacheName);
            return cache != null ? cache.get(key) : null;
        } catch (CacheException e) {
            LOGGER.warn(e.getMessage(), e);
            return null;
        }
    }
1121176
@Pure
	public N getChildAt(IcosepBinaryTreeZone zone) {
		if (zone == IcosepBinaryTreeZone.ICOSEP) {
			return this.nicosep;
		}
		return getChildAt(zone.toBinaryTreeZone());
	}
430213
public final HoconNodeCursor iterateChildren() {
    	ConfigValue n = currentNode();
        if (n == null) throw new IllegalStateException("No current node");
        boolean numericallyIndexed = isNumericallyIndexed(n);
        if (!numericallyIndexed) {
            if (isArray(n)) { // false since we have already returned START_ARRAY
                return new Array(n, this);
            }
            if (isObject(n)) {
                return new Object(n, this);
            }
        } else {
            return new NumericallyIndexedObjectBackedArray(n, this);
        }
        throw new IllegalStateException("Current node of type "+n.getClass().getName());
    }
458728
def child(role)
      @cached_children ||= {}
      @cached_children[role.to_sym] ||= self.children.where(:role => role).first || :nil
      @cached_children[role.to_sym] == :nil ? nil : @cached_children[role.to_sym]
    end
807344
@Override
    public int getChildCount(Object nodeObj) {
        if (debugger == null) {
            return 0;
        }
        VariableNode node = (VariableNode) nodeObj;
        return children(node).length;
    }
277018
public static Object getValue(Object instance, String fieldName) {
      Field f = findFieldRecursively(instance.getClass(), fieldName);
      if (f == null) throw new CacheException("Could not find field named '" + fieldName + "' on instance " + instance);
      try {
         f.setAccessible(true);
         return f.get(instance);
      } catch (IllegalAccessException iae) {
         throw new CacheException("Cannot access field " + f, iae);
      }
   }
816568
protected Object[] getChildren() {
        if (children != null) {
            return children;
        }

        ArrayList<DebugVariable> fields = mVariable.getFieldList();
        if (fields != null) {
            children = new VariableNode[fields.size()];
            for (int i = 0; i < fields.size(); i++) {
                DebugVariable variable = fields.get(i);
                children[i] = new VariableNode(variable);
            }
            return children;
        }
        return null;
    }
1137645
function() {
			if (!this.children.length)
				return null;
				
			var deepestChild = this;
			while (deepestChild.children.length) {
				deepestChild = deepestChild.children[deepestChild.children.length - 1];
			}
			
			return deepestChild;
		}
87549
public Map<String, byte[]> getCurrentMembers()
    {
        ImmutableMap.Builder<String, byte[]> builder = ImmutableMap.builder();
        boolean thisIdAdded = false;
        for ( ChildData data : cache.getCurrentData() )
        {
            String id = idFromPath(data.getPath());
            thisIdAdded = thisIdAdded || id.equals(thisId);
            builder.put(id, data.getData());
        }
        if ( !thisIdAdded )
        {
            builder.put(thisId, pen.getData());   // this instance is always a member
        }
        return builder.build();
    }