ea2ddl-gen/dbflute/templates/om/java/allcommon/cbean/sqlclause/OrderByClause.vm

   1 ${database.allClassCopyright}package ${glPackageBaseCommonSqlClause};\r
   2 \r
   3 #set ($myClassName = "${glOrderByClauseName}")\r
   4 import java.io.Serializable;\r
   5 import java.util.Map;\r
   6 import java.util.List;\r
   7 import java.util.ArrayList;\r
   8 import java.util.Iterator;\r
   9 import java.util.StringTokenizer;\r
  10 \r
  11 /**\r
  12  * @author ${database.ClassAuthor}\r
  13  */\r
  14 public class ${myClassName} implements Serializable {\r
  15 \r
  16     /** Serial version UID. (Default) */\r
  17     private static final long serialVersionUID = 1L;\r
  18 \r
  19     // =====================================================================================\r
  20     //                                                                             Attribute\r
  21     //                                                                             =========\r
  22     protected List<${glOrderByElementName}> _orderByList = new ArrayList<${glOrderByElementName}>();\r
  23 \r
  24     // =====================================================================================\r
  25     //                                                                           Constructor\r
  26     //                                                                           ===========\r
  27     /**\r
  28      * Constructor.\r
  29      */\r
  30     public ${myClassName}() {\r
  31     }\r
  32 \r
  33     // =====================================================================================\r
  34     //                                                                          Manipulation\r
  35     //                                                                          ============\r
  36     /**\r
  37      * Add order-by element.\r
  38      * @param orderByElement Order-by element. (NotNull)\r
  39      */\r
  40     public void addOrderByElement(${glOrderByElementName} orderByElement) {\r
  41         _orderByList.add(orderByElement);\r
  42     }\r
  43 \r
  44     /**\r
  45      * Insert first order-by element .\r
  46      * @param orderByElement Order-by element. (NotNull)\r
  47      */\r
  48     public void insertFirstOrderByElement(${glOrderByElementName} orderByElement) {\r
  49         _orderByList.add(0, orderByElement);\r
  50     }\r
  51 \r
  52     public void reverseAll() {\r
  53         for (Iterator<${glOrderByElementName}> ite = _orderByList.iterator(); ite.hasNext(); ) {\r
  54             ite.next().reverse();\r
  55         }\r
  56     }\r
  57 \r
  58     public void exchangeFirstOrderByElementForLastOne() {\r
  59         if (_orderByList.size() > 1) {\r
  60             final ${glOrderByElementName} first = _orderByList.get(0);\r
  61             final ${glOrderByElementName} last = _orderByList.get(_orderByList.size() - 1);\r
  62             _orderByList.set(0, last);\r
  63             _orderByList.set(_orderByList.size() - 1, first);\r
  64         }\r
  65     }\r
  66         \r
  67         public void addNullsFirstToPreviousOrderByElement(OrderByNullsSetupper filter) {\r
  68             if (_orderByList.isEmpty()) {\r
  69                     return;\r
  70                 }\r
  71                 final ${glOrderByElementName} last = _orderByList.get(_orderByList.size() - 1);\r
  72                 last.setOrderByNullsSetupper(filter, true);\r
  73         }\r
  74         \r
  75         public void addNullsLastToPreviousOrderByElement(OrderByNullsSetupper filter) {\r
  76             if (_orderByList.isEmpty()) {\r
  77                     return;\r
  78                 }\r
  79                 final ${glOrderByElementName} last = _orderByList.get(_orderByList.size() - 1);\r
  80                 last.setOrderByNullsSetupper(filter, false);\r
  81         }\r
  82         \r
  83         public static interface OrderByNullsSetupper {\r
  84         public String setup(String columnName, String orderByElementClause, boolean nullsFirst);\r
  85         }\r
  86 \r
  87     // =====================================================================================\r
  88     //                                                                   Order-By Expression\r
  89     //                                                                   ===================\r
  90     public List<${glOrderByElementName}> getOrderByList() {\r
  91         return _orderByList;\r
  92     }\r
  93 \r
  94     public String getOrderByClause() {\r
  95             return getOrderByClause(null);\r
  96     }\r
  97 \r
  98     public String getOrderByClause(Map<String, String> selectClauseRealColumnAliasMap) {\r
  99         if (_orderByList.isEmpty()) {\r
 100             return "";\r
 101         }\r
 102         final StringBuffer sb = new StringBuffer();\r
 103         final String delimiter = ", ";\r
 104         for (final Iterator<${glOrderByElementName}> ite = _orderByList.iterator(); ite.hasNext(); ) {\r
 105             final ${glOrderByElementName} element = ite.next();\r
 106             sb.append(delimiter);\r
 107                         if (selectClauseRealColumnAliasMap != null) {\r
 108                             sb.append(element.getElementClause(selectClauseRealColumnAliasMap));\r
 109                         } else {\r
 110                             sb.append(element.getElementClause());\r
 111                         }\r
 112         }\r
 113         sb.delete(0, delimiter.length()).insert(0, "order by ");\r
 114         return sb.toString();\r
 115     }\r
 116 \r
 117     public boolean isSameOrderByColumn(String orderByProperty) {\r
 118         final List<String> orderByList = new ArrayList<String>();\r
 119         {\r
 120             final StringTokenizer st = new StringTokenizer(orderByProperty, "/");\r
 121             while (st.hasMoreElements()) {\r
 122                 orderByList.add(st.nextToken());\r
 123             }\r
 124         }\r
 125         if (_orderByList.size() != orderByList.size()) {\r
 126             return false;\r
 127         }\r
 128         int count = 0;\r
 129         for (final Iterator<String> ite = orderByList.iterator(); ite.hasNext(); ) {\r
 130             final String columnFullName = ite.next();\r
 131             final ${glOrderByElementName} element = (${glOrderByElementName})_orderByList.get(count);\r
 132             if (!element.getColumnFullName().equals(columnFullName)) {\r
 133                 return false;\r
 134             }\r
 135             count++;\r
 136         }\r
 137         return true;\r
 138     }\r
 139 \r
 140     // =====================================================================================\r
 141     //                                                                         First Element\r
 142     //                                                                         =============\r
 143     public boolean isFirstElementAsc() {\r
 144         if (isEmpty()) {\r
 145             String msg = "This order-by clause is empty: " + toString();\r
 146             throw new IllegalStateException(msg);\r
 147         }\r
 148         final ${glOrderByElementName} element = (${glOrderByElementName})_orderByList.get(0);\r
 149         return element.isAsc();\r
 150     }\r
 151 \r
 152     public boolean isFirstElementDesc() {\r
 153         return !isFirstElementAsc();\r
 154     }\r
 155 \r
 156     public boolean isSameAsFirstElementAliasName(String expectedAliasName) {\r
 157         if (isEmpty()) {\r
 158             String msg = "This order-by clause is empty: " + toString();\r
 159             throw new RuntimeException(msg);\r
 160         }\r
 161         ${glOrderByElementName} element = (${glOrderByElementName})_orderByList.get(0);\r
 162         String actualAliasName = element.getAliasName();\r
 163         if (actualAliasName != null && expectedAliasName != null) {\r
 164             return actualAliasName.equalsIgnoreCase(expectedAliasName);\r
 165         } else {\r
 166             return false;\r
 167         }\r
 168     }\r
 169 \r
 170     /**\r
 171      * @param expectedColumnName Expected column-name. (Nullable)\r
 172      * @return Determination.\r
 173      */\r
 174     public boolean isSameAsFirstElementColumnName(String expectedColumnName) {\r
 175         if (isEmpty()) {\r
 176             String msg = "This order-by clause is empty: " + toString();\r
 177             throw new RuntimeException(msg);\r
 178         }\r
 179         ${glOrderByElementName} element = (${glOrderByElementName})_orderByList.get(0);\r
 180         String actualColumnName = element.getColumnName();\r
 181         if (actualColumnName != null && expectedColumnName != null) {\r
 182             return actualColumnName.equalsIgnoreCase(expectedColumnName);\r
 183         } else {\r
 184             return false;\r
 185         }\r
 186     }\r
 187 \r
 188     /**\r
 189      * @param expectedAliasName Expected alias-name. (Nullable)\r
 190      * @return Determination.\r
 191      */\r
 192     public boolean isSameAsFirstElementRegisteredAliasName(String expectedAliasName) {\r
 193         if (isEmpty()) {\r
 194             String msg = "This order-by clause is empty: " + toString();\r
 195             throw new RuntimeException(msg);\r
 196         }\r
 197         ${glOrderByElementName} element = (${glOrderByElementName})_orderByList.get(0);\r
 198         String actualAliasName = element.getRegisteredAliasName();\r
 199         if (actualAliasName != null && expectedAliasName != null) {\r
 200             return actualAliasName.equalsIgnoreCase(expectedAliasName);\r
 201         } else {\r
 202             return false;\r
 203         }\r
 204     }\r
 205 \r
 206     /**\r
 207      * @param expectedColumnName Expected column-name. (Nullable)\r
 208      * @return Determination.\r
 209      */\r
 210     public boolean isSameAsFirstElementRegisteredColumnName(String expectedColumnName) {\r
 211         if (isEmpty()) {\r
 212             String msg = "This order-by clause is empty: " + toString();\r
 213             throw new RuntimeException(msg);\r
 214         }\r
 215         ${glOrderByElementName} element = (${glOrderByElementName})_orderByList.get(0);\r
 216         String actualColumnName = element.getRegisteredColumnName();\r
 217         if (actualColumnName != null && expectedColumnName != null) {\r
 218             return actualColumnName.equalsIgnoreCase(expectedColumnName);\r
 219         } else {\r
 220             return false;\r
 221         }\r
 222     }\r
 223 \r
 224     // =====================================================================================\r
 225     //                                                                      Delegate of List\r
 226     //                                                                      ================\r
 227     /**\r
 228      * Is empty?\r
 229      * @return Determination.\r
 230      */\r
 231     public boolean isEmpty() {\r
 232         return _orderByList.isEmpty();\r
 233     }\r
 234 \r
 235     /**\r
 236      * Get iterator of order-by list.\r
 237      * @return Determination.\r
 238      */\r
 239     public Iterator<${glOrderByElementName}> iterator() {\r
 240         return _orderByList.iterator();\r
 241     }\r
 242 \r
 243     /**\r
 244      * Clear order-by list.\r
 245      */\r
 246     public void clear() {\r
 247         _orderByList.clear();\r
 248     }\r
 249 \r
 250     // =====================================================================================\r
 251     //                                                                        Basic Override\r
 252     //                                                                        ==============\r
 253     /**\r
 254      * This method overrides the method that is declared at super.\r
 255      * @return The view string of all-columns value. (NotNUll)\r
 256      */\r
 257     public String toString() {\r
 258         return _orderByList.toString();\r
 259     }\r
 260 }\r