Update ICU to 54.1 step 1

source/common/unicode/stringtriebuilder.h

 /*
 *******************************************************************************
-*   Copyright (C) 2010-2012, International Business Machines
+*   Copyright (C) 2010-2012,2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 *   file name:  stringtriebuilder.h
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2010dec24
 *   created by: Markus W. Scherer
 */
@@ skipping 141 matching lines @@
      * Makes sure that there is only one unique FinalValueNode registered
      * with this value.
      * Avoids creating a node if the value is a duplicate.
      * @param value A final value.
      * @param errorCode ICU in/out UErrorCode.
                         Set to U_MEMORY_ALLOCATION_ERROR if it was success but newNode==NULL.
      * @return A FinalValueNode with the given value.
      * @internal
      */
     Node *registerFinalValue(int32_t value, UErrorCode &errorCode);
+#endif  /* U_HIDE_INTERNAL_API */
 
     /*
      * C++ note:
      * registerNode() and registerFinalValue() take ownership of their input nodes,
      * and only return owned nodes.
      * If they see a failure UErrorCode, they will delete the input node.
      * If they get a NULL pointer, they will record a U_MEMORY_ALLOCATION_ERROR.
      * If there is a failure, they return NULL.
      *
      * NULL Node pointers can be safely passed into other Nodes because
      * they call the static Node::hashCode() which checks for a NULL pointer first.
      *
      * Therefore, as long as builder functions register a new node,
      * they need to check for failures only before explicitly dereferencing
      * a Node pointer, or before setting a new UErrorCode.
      */
 
     // Hash set of nodes, maps from nodes to integer 1.
     /** @internal */
     UHashtable *nodes;
 
+#ifndef U_HIDE_INTERNAL_API
     /** @internal */
     class Node : public UObject {
     public:
         Node(int32_t initialHash) : hash(initialHash), offset(0) {}
         inline int32_t hashCode() const { return hash; }
         // Handles node==NULL.
         static inline int32_t hashCode(const Node *node) { return node==NULL ? 0 : node->hashCode(); }
         // Base class operator==() compares the actual class types.
         virtual UBool operator==(const Node &other) const;
         inline UBool operator!=(const Node &other) const { return !operator==(other); }
@@ skipping 195 matching lines @@
     virtual int32_t writeValueAndFinal(int32_t i, UBool isFinal) = 0;
     /** @internal */
     virtual int32_t writeValueAndType(UBool hasValue, int32_t value, int32_t node) = 0;
     /** @internal */
     virtual int32_t writeDeltaTo(int32_t jumpTarget) = 0;
 };
 
 U_NAMESPACE_END
 
 #endif  // __STRINGTRIEBUILDER_H__